Yapılandırma türleri mi?

Question

Ben continuations üzerinde gidiyorum ve yapılandırma devam türleri için iki farklı yaklaşımlar rastlamak ettik: Ben ikinci yaklaşım gelmez anlıyoruz

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

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

... 

: Poor Mans Concurrency yer alan yaklaşıma karşı

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 

Açık bir veri kurucusu kullanmayın.

1. Bu yaklaşımların pratik farklılıkları nelerdir?

2. Bunu genel bir türden bir monad ile kullanmayı denediğimde etkilenir mi? Mesela:

   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

farklılıklar type ve newtype arasındaki olağan farklar vardır.

type eşanlamlı, varolan bir tür için yeni bir addır. type eş anlamlılar kısmen uygulanamaz, çünkü derleyici tür denetimi sırasında tanımı genişletir. onlar sarmak türlerine işlevsel olarak eşdeğer tip sistemde ayrı varlıklardır iken

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 s: Örneğin, bu bile TypeSynonymInstances ile hiçbir iyi vardır. Bu, newtype s 'un'un kısmen uygulanabileceği anlamına gelir.

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)