निरंतरता प्रकार का निर्माण?

Question

मैं निरंतरता से अधिक जा रहा हूँ और मैं संरचना निरंतरता प्रकार के लिए दो अलग-अलग दृष्टिकोण का सामना करना पड़ा:

newtype C r a = C {runC :: (a -> r) -> r} 

exampleFunction :: String -> C Bool String 
exampleFunction s = C $ \t -> if length s > 10 then t s else False 

continuationFunction :: String -> Bool 
continuationFunction s = True 

main = do 
let suspendedFunc = exampleFunction "testing" 
let completedFunc = runC suspendedFunc $ continuationFunction 

दृष्टिकोण Poor Mans Concurrency में लिया बनाम:

type C r a = (a -> r) -> r 

exampleFunction :: String -> C Bool String 
exampleFunction s = \t -> if length s > 10 then t s else False 

... 

मैं समझता हूँ कि बाद दृष्टिकोण नहीं करता है एक स्पष्ट डेटा कन्स्ट्रक्टर का उपयोग नहीं करते हैं।

1. इन दृष्टिकोणों के व्यावहारिक अंतर क्या हैं?

2. क्या यह प्रभाव तब होगा जब मैं इसे सामान्य प्रकार पर एक मोनड के साथ उपयोग करने का प्रयास करता हूं? जैसे:

   data Hole = Hole1 Int | Hole2 String 
   
   type C r m a = (a -> m r) -> m r 
   
   exampleFunction :: String -> C Bool Maybe Hole 
   exampleFunction s = \t -> do 
        x <- t (Hole1 11) 
        y <- t (Hole2 "test") 
        ... 
   
   continuationFunction :: Hole -> Bool 
   continuationFunction (Hole1 x) = False 
   continuationFunction (Hole2 y) = True 
   

Answer 1

मतभेद type और newtype के बीच सामान्य मतभेद हैं।

ए type समानार्थी मौजूदा प्रकार के लिए सिर्फ एक नया नाम है। type समानार्थी शब्द आंशिक रूप से लागू नहीं किए जा सकते हैं, क्योंकि संकलक प्रकार की जांच के दौरान परिभाषा का विस्तार करता है। ,

type TypeCont r a = (a -> r) -> r 

instance Monad (TypeCont r) where -- "The type synonym ‘TypeCont’ should have 2 arguments, but has been given 1" 
    return x = ($ x) 
    k >>= f = \q -> k (\x -> (f x) q) 

newtype रों जबकि प्रचालन प्रकार वे लपेट, के बराबर प्रकार प्रणाली में अलग संस्थाएं हैं: उदाहरण के लिए, यह कोई अच्छा, यहां तक ​​कि TypeSynonymInstances के साथ है। इसका मतलब है कि newtype s आंशिक रूप से लागू किया जा सकता है।

newtype NewtypeCont r a = Cont { runCont :: (a -> r) -> r } 

instance Monad (NewtypeCont r) where 
    return x = Cont ($ x) 
    Cont k >>= f = Cont $ \q -> k (\x -> runCont (f x) q)