Haskell Language
कॉफ़्री कोमोनॉड्स के आधार के रूप में सामान्य फ़ंक्शनलर्स

कॉफ्री खाली ~~ खाली

दिया हुआ

data Empty a

हमारे पास है

data Cofree Empty a
   --  = a :< ...  not possible!

कोफ्री (कॉन्स्ट सी) ~~ लेखक सी

दिया हुआ

data Const c a = Const c

हमारे पास है

data Cofree (Const c) a
     = a :< Const c

जो isomorphic है

data Writer c a = Writer c a

कॉफ्री आइडेंटिटी ~~ स्ट्रीम

दिया हुआ

data Identity a = Identity a

हमारे पास है

data Cofree Identity a
     = a :< Identity (Cofree Identity a)

जो isomorphic है

data Stream a = Stream a (Stream a)

कोफ्री हो सकता है ~~ NonEmpty

दिया हुआ

data Maybe a = Just a
             | Nothing

हमारे पास है

data Cofree Maybe a
     = a :< Just (Cofree Maybe a)
     | a :< Nothing

जो isomorphic है

data NonEmpty a
     = NECons a (NonEmpty a)
     | NESingle a

कॉफ्री (लेखक डब्ल्यू) ~~ लेखक डब्ल्यू स्ट्रीम

दिया हुआ

data Writer w a = Writer w a

हमारे पास है

data Cofree (Writer w) a
     = a :< (w, Cofree (Writer w) a)

के बराबर है

data Stream (w,a)
     = Stream (w,a) (Stream (w,a))

जिसे WriterT w Stream साथ ठीक से लिखा जा सकता है

data WriterT w m a = WriterT (m (w,a))

कॉफ्री (Either e) ~~ NonEmptyT (लेखक ई)

दिया हुआ

data Either e a = Left e
                | Right a

हमारे पास है

data Cofree (Either e) a
     = a :< Left e
     | a :< Right (Cofree (Either e) a)

जो isomorphic है

data Hospitable e a
     = Sorry_AllIHaveIsThis_Here'sWhy a e
     | EatThis a (Hospitable e a)

या, यदि आप पूर्ण परिणाम के बाद केवल लॉग का मूल्यांकन करने का वादा करते हैं, तो NonEmptyT (Writer e) a साथ

data NonEmptyT (Writer e) a = NonEmptyT (e,a,[a])

कोफ्री (रीडर x) ~~ मूर x

दिया हुआ

data Reader x a = Reader (x -> a)

हमारे पास है

data Cofree (Reader x) a
     = a :< (x -> Cofree (Reader x) a)

जो isomorphic है

data Plant x a
     = Plant a (x -> Plant x a)

उर्फ मूर मशीन ।