Haskell Language
monoid

सूचियों के लिए मोनॉइड का एक उदाहरण

instance Monoid [a] where
    mempty  = []
    mappend = (++)

इस उदाहरण के लिए Monoid कानूनों की जाँच:

mempty `mappend` x = x   <->   [] ++ xs = xs  -- prepending an empty list is a no-op

x `mappend` mempty = x   <->   xs ++ [] = xs  -- appending an empty list is a no-op

x `mappend` (y `mappend` z) = (x `mappend` y) `mappend` z
    <->
xs ++ (ys ++ zs) = (xs ++ ys) ++ zs           -- appending lists is associative

एकल मूल्य में मोनॉयड की एक सूची को संकुचित करना

mconcat :: [a] -> a और प्रकार की Monoid टाइपकास्ट है :

ghci> mconcat [Sum 1, Sum 2, Sum 3]
Sum {getSum = 6}
ghci> mconcat ["concat", "enate"]
"concatenate"

इसकी डिफ़ॉल्ट परिभाषा mconcat = foldr mappend mempty ।

न्यूमेरिक मोनॉयड

नंबर दो तरह से monoidal हैं: इकाई, और 1 इकाई के रूप में साथ गुणा के रूप में 0 के साथ इसके अलावा। दोनों अलग-अलग परिस्थितियों में समान रूप से मान्य और उपयोगी हैं। इसलिए संख्याओं के लिए एक पसंदीदा उदाहरण चुनने के बजाय, विभिन्न कार्यक्षमता के लिए उन्हें टैग करने के लिए दो newtypes , Sum और Product ।

newtype Sum n = Sum { getSum :: n }

instance Num n => Monoid (Sum n) where
    mempty = Sum 0
    Sum x `mappend` Sum y = Sum (x + y)

newtype Product n = Product { getProduct :: n }

instance Num n => Monoid (Product n) where
    mempty = Product 1
    Product x `mappend` Product y = Product (x * y)

यह प्रभावी रूप से डेवलपर को उचित newtype में मूल्य को लपेटकर किस कार्यक्षमता का उपयोग करने के लिए चुनने की अनुमति देता है।

Sum 3     <> Sum 5     == Sum 8
Product 3 <> Product 5 == Product 15

() के लिए मोनॉयड का एक उदाहरण

() एक Monoid । चूँकि केवल एक ही प्रकार का मान है () , केवल एक ही चीज़ mempty और mappend कर सकता है:

instance Monoid () where
    mempty = ()
    () `mappend` () = ()