आवेदक यह है कि एक्स को क्या करना है

Question

क्या हम एक्स के लिए इस समीकरण को हल कर सकते हैं?

अनुप्रयोगी इकाई के लिए क्या एक्स

Answer 1

comonad करने के लिए इसे कुछ सोचा देने के बाद है, मुझे लगता है कि यह वास्तव में एक पिछड़े सवाल है। कोई सोच सकता है कि ComonadApplyComonadApplicativeMonad है, लेकिन ऐसा नहीं है। लेकिन इस को देखने के लिए, हमें PureScript के typeclass पदानुक्रम का उपयोग करते हैं:

class Functor f where 
    fmap :: (a -> b) -> f a -> f b 

class Functor f => Apply f where 
    apply :: f (a -> b) -> f a -> f b -- (<*>) 

class Apply f => Applicative f where 
    pure :: a -> f a 

class Applicative m => Monad m where 
    bind :: m a -> (a -> m b) -> m b -- (>>=) 
-- join :: m (m a) -> m a 
-- join = flip bind id 

आप देख सकते हैं, ComonadApply केवल (Apply w, Comonad w) => w है। हालांकि, Applicativepure के साथ मज़ेदार में मूल्य इंजेक्षन करने की क्षमता वास्तविक अंतर है।

स्पष्ट दोहरी के रूप में एक Comonad की परिभाषा return के होते हैं की दोहरी extract और bind की दोहरी extend (या के माध्यम से वैकल्पिक definiton duplicate रूप join की दोहरी):

class Functor w => Comonad w where 
    extract :: w a -> a   
    extend :: (w a -> b) -> w a -> w b 
-- extend f = fmap f . duplicate k 
-- duplicate :: w a -> w (w a) 
-- duplicate = extend id 

तो अगर हम Monad को Applicative से कदम को देखते हैं, के बीच तार्किक कदम के साथ एक typeclass होगा pure की दोहरी:

class Apply w => Extract w where 
    extract :: w a -> a 

class Extract w => Comonad w where 
    extend :: (w a -> b) -> w a -> w b 

ध्यान दें कि हम extend या duplicate के मामले में extract परिभाषित कर सकते हैं नहीं, और न ही हम bind या join के मामले में pure/return परिभाषित कर सकते हैं, तो यह "तार्किक" कदम की तरह लगता है। apply अधिकतर अप्रासंगिक है; यह, या तो Extract या Monad के लिए परिभाषित किया जा सकता जब तक कि उनके कानूनों पकड़:

applyC f = fmap $ extract f -- Comonad variant; needs only Extract actually (*) 
applyM f = bind f . flip fmap -- Monad variant; we need join or bind 

तो Extract (मान रही बाहर) Comonad क्या Applicative (में मान रही) को Monad करना है। Apply रास्ते में कम से कम एक छोटा सा दुर्घटना है। यह दिलचस्प होगा कि हैस्क में ऐसे प्रकार हैं जिनमें Extract है, लेकिन Comonad (या Extend नहीं, लेकिन Comonad नहीं, नीचे देखें), लेकिन मुझे लगता है कि वे दुर्लभ हैं।

ध्यान दें कि Extract — मौजूद नहीं है। लेकिन 2010 report में Applicative न तो किया। इसके अलावा, किसी भी प्रकार की स्वचालित रूप से दोनों Extract का एक उदाहरण और Applicative है कि, दोनों एक Monad और एक Comonad है जब से तुम extract और pure के मामले में bind और extend परिभाषित कर सकते हैं:

bindC :: Extract w => w a -> (a -> w b) -> w b 
bindC k f = f $ extract k 

extendM :: Applicative w => (w a -> b) -> w a -> w b 
extendM f k = pure $ f k  

_{* apply परिभाषित करने में सक्षम होने के नाते extract के संदर्भ में एक संकेत है कि class Extend w => Comonad w अधिक व्यवहार्य हो सकता है, लेकिन कोई Monadclass (Applicative f, Bind f) => Monad f में विभाजित कर सकता है और इसलिए Comonad(Extend w, Extract w) => Comonad w में, इसलिए यह कम या ज्यादा विभाजित बाल है।}