tl; डॉ
{-# LANGUAGE InstanceSigs #-}
newtype Id t = Id t
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
प्रस्ताव
$कार्यों के अनुप्रयोग ऑपरेटर
forall a b. a -> b
विहित रूप से परिभाषित किया गया है
($) :: (a -> b) -> a -> b
f $ x = f x
infixr 0 $
हास्केल-आदिम फ़ंक्शन एप्लिकेशन f x( infixl 10) के संदर्भ में ।
संरचना .के संदर्भ में परिभाषित किया गया है $के रूप में
(.) :: (b -> c) -> (a -> b) -> (a -> c)
f . g = \ x -> f $ g x
infixr 9 .
और समकक्षों को संतुष्ट करता है forall f g h.
f . id = f :: c -> d Right identity
id . g = g :: b -> c Left identity
(f . g) . h = f . (g . h) :: a -> d Associativity
.साहचर्य है, और idइसकी दाईं और बाईं पहचान है।
क्लेली ट्रिपल
प्रोग्रामिंग में, एक मोनाड एक फनकार टाइप कंस्ट्रक्टर होता है जिसमें मोनैड टाइप क्लास होता है। परिभाषा और कार्यान्वयन के कई समतुल्य रूप हैं, प्रत्येक में मोनड अमूर्तता के बारे में थोड़ा अलग अंतर्ज्ञान है।
एक functor एक प्रकार निर्माता है fएक तरह से * -> *functor प्रकार वर्ग का एक उदाहरण के साथ।
{-# LANGUAGE KindSignatures #-}
class Functor (f :: * -> *) where
map :: (a -> b) -> (f a -> f b)
वैधानिक रूप से लागू प्रकार प्रोटोकॉल का पालन करने के अलावा, फफूंद प्रकार वर्ग के उदाहरणों को बीजीय फफूंद कानूनों का पालन करना चाहिए forall f g.
map id = id :: f t -> f t Identity
map f . map g = map (f . g) :: f a -> f c Composition / short cut fusion
फन्नेटर कंप्यूटर्स के प्रकार होते हैं
forall f t. Functor f => f t
एक संगणना c rमें संदर्भ के भीतर परिणाम शामिल होते हैं ।r c
असमान मोनोडिक फ़ंक्शंस या क्लेज़ली तीरों का प्रकार होता है
forall m a b. Functor m => a -> m b
क्लेसी तीर ऐसे कार्य हैं जो एक तर्क लेते हैं aऔर एक मोनडिक अभिकलन वापस करते हैंm b ।
क्लेडिस ट्रिपल के संदर्भ में मोनोड को कैनोनिक रूप से परिभाषित किया गया है forall m. Functor m =>
(m, return, (=<<))
प्रकार वर्ग के रूप में लागू किया गया
class Functor m => Monad m where
return :: t -> m t
(=<<) :: (a -> m b) -> m a -> m b
infixr 1 =<<
Kleisli पहचान return एक Kleisli तीर एक मूल्य को बढ़ावा देता है tmonadic संदर्भ में m। एक्सटेंशन या क्लेसीली आवेदन एक संगणना के परिणामों के लिए =<<क्लेस्ली तीर लागू a -> m bकरता हैm a ।
क्लेसली रचना <=< को विस्तार के संदर्भ में परिभाषित किया गया है
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
f <=< g = \ x -> f =<< g x
infixr 1 <=<
<=< दो क्लीसली तीरों की रचना करता है, दाएं तीर के अनुप्रयोग के परिणामों के लिए बाएं तीर को लागू करता है।
मोनाद प्रकार के वर्ग के उदाहरणों को मोनाद कानूनों का पालन करना चाहिए , जो कि ज्यादातर क्लेसीली रचना के संदर्भ में कहा गया है:forall f g h.
f <=< return = f :: c -> m d Right identity
return <=< g = g :: b -> m c Left identity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d Associativity
<=<साहचर्य है, और returnइसकी दाईं और बाईं पहचान है।
पहचान
पहचान का प्रकार
type Id t = t
प्रकारों पर पहचान कार्य है
Id :: * -> *
एक फ़नकार के रूप में व्याख्या की गई,
return :: t -> Id t
= id :: t -> t
(=<<) :: (a -> Id b) -> Id a -> Id b
= ($) :: (a -> b) -> a -> b
(<=<) :: (b -> Id c) -> (a -> Id b) -> (a -> Id c)
= (.) :: (b -> c) -> (a -> b) -> (a -> c)
विहित हास्केल में, पहचान मोनड को परिभाषित किया गया है
newtype Id t = Id t
instance Functor Id where
map :: (a -> b) -> Id a -> Id b
map f (Id x) = Id (f x)
instance Monad Id where
return :: t -> Id t
return = Id
(=<<) :: (a -> Id b) -> Id a -> Id b
f =<< (Id x) = f x
विकल्प
एक विकल्प प्रकार
data Maybe t = Nothing | Just t
सांकेतिक शब्दों में बदलना गणना है Maybe tकि जरूरी नहीं कि एक परिणाम देता है t, अभिकलन "विफल" हो सकता है। विकल्प मोनड को परिभाषित किया गया है
instance Functor Maybe where
map :: (a -> b) -> (Maybe a -> Maybe b)
map f (Just x) = Just (f x)
map _ Nothing = Nothing
instance Monad Maybe where
return :: t -> Maybe t
return = Just
(=<<) :: (a -> Maybe b) -> Maybe a -> Maybe b
f =<< (Just x) = f x
_ =<< Nothing = Nothing
a -> Maybe bएक परिणाम के लिए लागू होता है केवल अगर Maybe aएक परिणाम देता है।
newtype Nat = Nat Int
प्राकृतिक संख्याओं को उन पूर्णांकों के रूप में एन्कोड किया जा सकता है जो शून्य से अधिक या उसके बराबर हैं।
toNat :: Int -> Maybe Nat
toNat i | i >= 0 = Just (Nat i)
| otherwise = Nothing
प्राकृतिक संख्या घटाव के तहत बंद नहीं होती हैं।
(-?) :: Nat -> Nat -> Maybe Nat
(Nat n) -? (Nat m) = toNat (n - m)
infixl 6 -?
विकल्प मोनाड अपवाद हैंडलिंग का एक मूल रूप शामिल करता है।
(-? 20) <=< toNat :: Int -> Maybe Nat
सूची
सूची प्रकार पर, सूची मोनाद
data [] t = [] | t : [t]
infixr 5 :
और इसके additive मोनॉयड ऑपरेशन "परिशिष्ट"
(++) :: [t] -> [t] -> [t]
(x : xs) ++ ys = x : xs ++ ys
[] ++ ys = ys
infixr 5 ++
परिणामों की एक प्राकृतिक राशि उपज nonlinear संगणना सांकेतिक शब्दों में बदलना ।[t]0, 1, ...t
instance Functor [] where
map :: (a -> b) -> ([a] -> [b])
map f (x : xs) = f x : map f xs
map _ [] = []
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> [a] -> [b]
f =<< (x : xs) = f x ++ (f =<< xs)
_ =<< [] = []
एक्सटेंशन =<<concatenates ++सभी सूचियों [b]अनुप्रयोगों से उत्पन्न f xएक Kleisli के तीर a -> [b]के तत्वों को [a]एक ही परिणाम सूची में[b] ।
एक सकारात्मक पूर्णांक के उचित विभाजक nहोने दें
divisors :: Integral t => t -> [t]
divisors n = filter (`divides` n) [2 .. n - 1]
divides :: Integral t => t -> t -> Bool
(`divides` n) = (== 0) . (n `rem`)
फिर
forall n. let { f = f <=< divisors } in f n = []
मानद प्रकार वर्ग को परिभाषित करने में, विस्तार के बजाय =<<, हास्केल मानक अपने फ्लिप, बाइंड ऑपरेटर का उपयोग करता है >>=।
class Applicative m => Monad m where
(>>=) :: forall a b. m a -> (a -> m b) -> m b
(>>) :: forall a b. m a -> m b -> m b
m >> k = m >>= \ _ -> k
{-# INLINE (>>) #-}
return :: a -> m a
return = pure
सादगी की खातिर, यह स्पष्टीकरण प्रकार श्रेणी पदानुक्रम का उपयोग करता है
class Functor f
class Functor m => Monad m
हास्केल में, वर्तमान मानक पदानुक्रम है
class Functor f
class Functor p => Applicative p
class Applicative m => Monad m
क्योंकि न केवल हर मोनाड एक फनकार है, बल्कि हर मादक एक फनकार है और हर मोनाड एक ऐक्यूटिव भी है।
सूची का उपयोग करते हुए मोनाड, अनिवार्य छद्मकोश
for a in (1, ..., 10)
for b in (1, ..., 10)
p <- a * b
if even(p)
yield p
मोटे तौर पर डो ब्लॉक में अनुवाद करता है ,
do a <- [1 .. 10]
b <- [1 .. 10]
let p = a * b
guard (even p)
return p
बराबर मोनाड की समझ ,
[ p | a <- [1 .. 10], b <- [1 .. 10], let p = a * b, even p ]
और अभिव्यक्ति
[1 .. 10] >>= (\ a ->
[1 .. 10] >>= (\ b ->
let p = a * b in
guard (even p) >> -- [ () | even p ] >>
return p
)
)
नेशन बाइंड एक्सप्रेशन के लिए नोटेशन और मोनाड कॉम्प्रिहेंशन सिंटैक्टिक शुगर हैं। बाइंड ऑपरेटर का उपयोग स्थानीय नाम बाध्यकारी परिणामों के लिए किया जाता है।
let x = v in e = (\ x -> e) $ v = v & (\ x -> e)
do { r <- m; c } = (\ r -> c) =<< m = m >>= (\ r -> c)
कहाँ पे
(&) :: a -> (a -> b) -> b
(&) = flip ($)
infixl 0 &
गार्ड फ़ंक्शन को परिभाषित किया गया है
guard :: Additive m => Bool -> m ()
guard True = return ()
guard False = fail
जहां इकाई प्रकार या "खाली टपल"
data () = ()
Additive monads कि समर्थन विकल्प और विफलता एक प्रकार वर्ग का उपयोग करने पर निकाला जा सकता है
class Monad m => Additive m where
fail :: m t
(<|>) :: m t -> m t -> m t
infixl 3 <|>
instance Additive Maybe where
fail = Nothing
Nothing <|> m = m
m <|> _ = m
instance Additive [] where
fail = []
(<|>) = (++)
जहाँ failऔर <|>एक मोनॉयड बनाते हैंforall k l m.
k <|> fail = k
fail <|> l = l
(k <|> l) <|> m = k <|> (l <|> m)
और failadditive भिक्षुओं के शून्य तत्व को अवशोषित / नष्ट करना है
_ =<< fail = fail
मैं फ़िन
guard (even p) >> return p
even pयह सच है, तब गार्ड , स्थानीय स्थिर फ़ंक्शन [()]की परिभाषा के अनुसार उत्पादन करता है , और>>
\ _ -> return p
परिणाम पर लागू होता है ()। यदि गलत है, तो गार्ड सूची मोनाद fail( []) का उत्पादन करता है , जो क्लेस्ली तीर के लिए कोई परिणाम नहीं देता >>है, ताकि इसे लागू किया जा सकेp पर छोड़ दिया जाता है।
राज्य
बदनाम रूप से, संन्यासी का उपयोग संस्थागत गणना को सांकेतिक करने के लिए किया जाता है।
एक राज्य प्रोसेसर एक फ़ंक्शन है
forall st t. st -> (t, st)
जो एक स्थिति का संक्रमण करता है stऔर एक परिणाम देता है t। राज्य st में कुछ भी हो सकता है। कुछ नहीं, झंडा, गिनती, सरणी, संभाल, मशीन, दुनिया।
राज्य प्रोसेसर का प्रकार आमतौर पर कहा जाता है
type State st t = st -> (t, st)
राज्य प्रोसेसर इकाई kinded है * -> *functor State st। राज्य प्रोसेसर मोनाड के क्लेली तीर कार्य हैं
forall st a b. a -> (State st) b
कैनोनिकल हास्केल में, राज्य प्रोसेसर मोनाड का आलसी संस्करण परिभाषित किया गया है
newtype State st t = State { stateProc :: st -> (t, st) }
instance Functor (State st) where
map :: (a -> b) -> ((State st) a -> (State st) b)
map f (State p) = State $ \ s0 -> let (x, s1) = p s0
in (f x, s1)
instance Monad (State st) where
return :: t -> (State st) t
return x = State $ \ s -> (x, s)
(=<<) :: (a -> (State st) b) -> (State st) a -> (State st) b
f =<< (State p) = State $ \ s0 -> let (x, s1) = p s0
in stateProc (f x) s1
एक राज्य प्रोसेसर एक प्रारंभिक राज्य की आपूर्ति द्वारा चलाया जाता है:
run :: State st t -> st -> (t, st)
run = stateProc
eval :: State st t -> st -> t
eval = fst . run
exec :: State st t -> st -> st
exec = snd . run
राज्य पहुँच पुरातन द्वारा प्रदान की जाती है getऔर put, अधिक अमूर्त के तरीकों स्टेटफुल monads:
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
class Monad m => Stateful m st | m -> st where
get :: m st
put :: st -> m ()
m -> stभिक्षु पर राज्य प्रकार की कार्यात्मक निर्भरता की घोषणा करता है ; एक है कि , उदाहरण के लिए, राज्य प्रकार का निर्धारण हो जाएगा विशिष्ट।stmState tt
instance Stateful (State st) st where
get :: State st st
get = State $ \ s -> (s, s)
put :: st -> State st ()
put s = State $ \ _ -> ((), s)
इकाई प्रकार के साथ voidC में समान रूप से उपयोग किया जाता है।
modify :: Stateful m st => (st -> st) -> m ()
modify f = do
s <- get
put (f s)
gets :: Stateful m st => (st -> t) -> m t
gets f = do
s <- get
return (f s)
gets अक्सर रिकॉर्ड फ़ील्ड एक्सेसर्स के साथ उपयोग किया जाता है।
चर सूत्रण के बराबर राज्य मोनाद
let s0 = 34
s1 = (+ 1) s0
n = (* 12) s1
s2 = (+ 7) s1
in (show n, s2)
जहां s0 :: Int, समान रूप से पारदर्शी पारदर्शी है, लेकिन असीम रूप से अधिक सुरुचिपूर्ण और व्यावहारिक है
(flip run) 34
(do
modify (+ 1)
n <- gets (* 12)
modify (+ 7)
return (show n)
)
modify (+ 1)State Int ()इसके समान प्रभाव को छोड़कर, प्रकार की गणना है return ()।
(flip run) 34
(modify (+ 1) >>
gets (* 12) >>= (\ n ->
modify (+ 7) >>
return (show n)
)
)
सहानुभूति के मोनड कानून के संदर्भ में लिखा जा सकता है >>= forall m f g.
(m >>= f) >>= g = m >>= (\ x -> f x >>= g)
या
do { do { do {
r1 <- do { x <- m; r0 <- m;
r0 <- m; = do { = r1 <- f r0;
f r0 r1 <- f x; g r1
}; g r1 }
g r1 }
} }
अभिव्यक्ति-उन्मुख प्रोग्रामिंग (जैसे जंग) में, एक ब्लॉक का अंतिम बयान इसकी उपज का प्रतिनिधित्व करता है। बाइंड ऑपरेटर को कभी-कभी "प्रोग्रामेबल अर्धविराम" कहा जाता है।
संरचित अनिवार्य प्रोग्रामिंग से Iteration control संरचना प्राइमेटरी मोनोडिक रूप से अनुकरण की जाती है
for :: Monad m => (a -> m b) -> [a] -> m ()
for f = foldr ((>>) . f) (return ())
while :: Monad m => m Bool -> m t -> m ()
while c m = do
b <- c
if b then m >> while c m
else return ()
forever :: Monad m => m t
forever m = m >> forever m
इनपुट आउटपुट
data World
I / O वर्ल्ड स्टेट प्रोसेसर मोनाड शुद्ध हास्केल और वास्तविक दुनिया का एक मेल है, जो कार्यात्मक संप्रदाय और अनिवार्य परिचालन शब्दार्थ का है। वास्तविक सख्त कार्यान्वयन का एक नजदीकी एनालॉग:
type IO t = World -> (t, World)
बातचीत को अशुद्ध आदिमियों द्वारा सुगम बनाया गया है
getChar :: IO Char
putChar :: Char -> IO ()
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
hSetBuffering :: Handle -> BufferMode -> IO ()
hTell :: Handle -> IO Integer
. . . . . .
कोड का उपयोग करने वाली अशुद्धता, IOस्थायी रूप से टाइप सिस्टम द्वारा प्रोटोकॉल है। क्योंकि पवित्रता भयानक है, इसमें क्या होता है IO, इसमें रहता है IO।
unsafePerformIO :: IO t -> t
या, कम से कम, चाहिए।
हास्केल कार्यक्रम का प्रकार हस्ताक्षर
main :: IO ()
main = putStrLn "Hello, World!"
तक फैलता है
World -> ((), World)
एक फ़ंक्शन जो एक दुनिया को बदल देता है।
उपसंहार
जिस श्रेणी की वस्तुएं हास्केल प्रकार की होती हैं और हस्केल प्रकारों के बीच कार्य करता है, वह श्रेणी "तेज और ढीली" है Hask।
एक फ़नकार Tएक श्रेणी से एक श्रेणी के Cलिए एक मानचित्रण है D; में प्रत्येक वस्तु के लिए Cमें एक वस्तुD
Tobj : Obj(C) -> Obj(D)
f :: * -> *
और में प्रत्येक आकारिता के लिए Cमें एक आकारिताD
Tmor : HomC(X, Y) -> HomD(Tobj(X), Tobj(Y))
map :: (a -> b) -> (f a -> f b)
जहाँ X, Yमें वस्तुएँ हैं C। HomC(X, Y)है समरूपता वर्ग सभी morphisms की X -> Yमें C। फ़नकार को मॉर्फ़िज़्म आइडेंटिटी और कंपोज़िशन को संरक्षित करना चाहिए, जिसमें "स्ट्रक्चर" Cइन है D।
Tmor Tobj
T(id) = id : T(X) -> T(X) Identity
T(f) . T(g) = T(f . g) : T(X) -> T(Z) Composition
एक श्रेणी की क्लेइस्ली श्रेणीC क्लेइस्ली ट्रिपल द्वारा दी गई है
<T, eta, _*>
एंडोफूनक्टर का
T : C -> C
( f), एक पहचान आकारिकी eta( return), और एक विस्तार ऑपरेटर *( =<<)।
प्रत्येक क्लेली मॉर्फिज़्म में Hask
f : X -> T(Y)
f :: a -> m b
विस्तार ऑपरेटर द्वारा
(_)* : Hom(X, T(Y)) -> Hom(T(X), T(Y))
(=<<) :: (a -> m b) -> (m a -> m b)
Haskक्लेइस्ली श्रेणी में एक रूपवाद दिया जाता है
f* : T(X) -> T(Y)
(f =<<) :: m a -> m b
क्लेस्ली श्रेणी में रचना .Tविस्तार के संदर्भ में दी गई है
f .T g = f* . g : X -> T(Z)
f <=< g = (f =<<) . g :: a -> m c
और श्रेणी स्वयंसिद्धों को संतुष्ट करता है
eta .T g = g : Y -> T(Z) Left identity
return <=< g = g :: b -> m c
f .T eta = f : Z -> T(U) Right identity
f <=< return = f :: c -> m d
(f .T g) .T h = f .T (g .T h) : X -> T(U) Associativity
(f <=< g) <=< h = f <=< (g <=< h) :: a -> m d
जो, तुल्यता परिवर्तनों को लागू करना
eta .T g = g
eta* . g = g By definition of .T
eta* . g = id . g forall f. id . f = f
eta* = id forall f g h. f . h = g . h ==> f = g
(f .T g) .T h = f .T (g .T h)
(f* . g)* . h = f* . (g* . h) By definition of .T
(f* . g)* . h = f* . g* . h . is associative
(f* . g)* = f* . g* forall f g h. f . h = g . h ==> f = g
विस्तार के संदर्भ में विहित रूप से दिए गए हैं
eta* = id : T(X) -> T(X) Left identity
(return =<<) = id :: m t -> m t
f* . eta = f : Z -> T(U) Right identity
(f =<<) . return = f :: c -> m d
(f* . g)* = f* . g* : T(X) -> T(Z) Associativity
(((f =<<) . g) =<<) = (f =<<) . (g =<<) :: m a -> m c
मोनाड्स को क्लेसीलियन एक्सटेंशन के नहीं, बल्कि muप्रोग्रामिंग में एक प्राकृतिक परिवर्तन के रूप में परिभाषित किया जा सकता है join। एक मोनाड को muएक श्रेणी के एक ट्रिपल के रूप में परिभाषित किया जाता है C, एक एंडोफ़नक्टर का
T : C -> C
f :: * -> *
और दो प्राकृतिक ट्रांसफॉर्मेशन
eta : Id -> T
return :: t -> f t
mu : T . T -> T
join :: f (f t) -> f t
समतुल्यता को संतुष्ट करना
mu . T(mu) = mu . mu : T . T . T -> T . T Associativity
join . map join = join . join :: f (f (f t)) -> f t
mu . T(eta) = mu . eta = id : T -> T Identity
join . map return = join . return = id :: f t -> f t
मोनड प्रकार वर्ग तब परिभाषित किया गया है
class Functor m => Monad m where
return :: t -> m t
join :: m (m t) -> m t
muविकल्प सनद के विहित कार्यान्वयन:
instance Monad Maybe where
return = Just
join (Just m) = m
join Nothing = Nothing
concatसमारोह
concat :: [[a]] -> [a]
concat (x : xs) = x ++ concat xs
concat [] = []
है joinसूची इकाई की।
instance Monad [] where
return :: t -> [t]
return = (: [])
(=<<) :: (a -> [b]) -> ([a] -> [b])
(f =<<) = concat . map f
के क्रियान्वयन joinतुल्यता का उपयोग कर विस्तार रूप से अनुवाद किया जा सकता
mu = id* : T . T -> T
join = (id =<<) :: m (m t) -> m t
muएक्सटेंशन फॉर्म से रिवर्स ट्रांसलेशन द्वारा दिया गया है
f* = mu . T(f) : T(X) -> T(Y)
(f =<<) = join . map f :: m a -> m b
लेकिन प्रोग्रामिंग के लिए किसी सिद्धांत का इतना सार क्यों होना चाहिए?
उत्तर सरल है: कंप्यूटर वैज्ञानिकों के रूप में, हम अमूर्तता को महत्व देते हैं ! जब हम किसी सॉफ़्टवेयर घटक के लिए इंटरफ़ेस डिज़ाइन करते हैं, तो हम चाहते हैं कि यह कार्यान्वयन के बारे में जितना संभव हो उतना कम प्रकट हो। हम कार्यान्वयन को कई विकल्पों, एक ही 'अवधारणा' के कई अन्य 'उदाहरणों' के साथ बदलने में सक्षम होना चाहते हैं। जब हम कई प्रोग्राम पुस्तकालयों में एक सामान्य इंटरफ़ेस डिज़ाइन करते हैं, तो यह और भी महत्वपूर्ण है कि हम जो इंटरफ़ेस चुनते हैं, उसमें कई प्रकार के कार्यान्वयन हैं। यह मोनड अवधारणा की व्यापकता है जिसे हम बहुत अधिक महत्व देते हैं, ऐसा इसलिए है क्योंकि श्रेणी सिद्धांत इतना सार है कि इसकी अवधारणा प्रोग्रामिंग के लिए बहुत उपयोगी है।
यह, शायद ही आश्चर्य की बात है, कि हम नीचे प्रस्तुत भिक्षुओं के सामान्यीकरण का भी श्रेणी सिद्धांत से गहरा संबंध है। लेकिन हम इस बात पर जोर देते हैं कि हमारा उद्देश्य बहुत व्यावहारिक है: यह 'श्रेणी सिद्धांत को लागू करने' के लिए नहीं है, यह कॉम्बिनेटर पुस्तकालयों की संरचना के लिए एक अधिक सामान्य तरीका खोजना है। यह बस हमारा सौभाग्य है कि गणितज्ञों ने हमारे लिए बहुत काम किया है!
से तीर को Generalising monads जॉन ह्यूजेस द्वारा
