tl; dr
{-# 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
ගණනය කිරීම සන්දර්භය තුළ ප්‍රති results ල c rවලින් සමන්විත වේ . r c
ඒකීය මොනාඩික් ශ්‍රිත හෝ ක්ලයිස්ලි ඊතල වල වර්ගය ඇත
forall m a b. Functor m => a -> m b
Kleisi ඊතල එක් තර්කයක් ගෙන ක්රියාත්මක වන බව ය aසහ monadic ගණනය නැවත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 bresults ල සඳහා ක්ලයිස්ලි ඊතලයක් යොදයි m a.
ක්ලයිස්ලි සංයුතිය දීර් <=< extension කිරීම අනුව අර්ථ දැක්වේ
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
f <=< g = \ x -> f =<< g x
infixr 1 <=<
<=< ක්ලයිස්ලි ඊතල දෙකක් රචනා කරයි, දකුණු ඊතලයේ යෙදුමේ ප්‍රති results ල සඳහා වම් ඊතලය යොදන්න.
මොනාඩ් වර්ගයේ පන්තියේ අවස්ථා මොනාඩ් නීතිවලට අවනත විය යුතුය , ක්ලයිස්ලි සංයුතිය අනුව වඩාත් අලංකාර ලෙස ප්‍රකාශ කර ඇත: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 tresult ලයක් අවශ්‍ය නොවන ගණනය කිරීම සංකේතවත් කරයි 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ප්‍රති result ලයකට අදාළ වන්නේ ප්‍රති .ලයක් ලැබෙන්නේ නම් පමණි 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 :
සහ එහි ආකලන මොනොයිඩ් ක්‍රියාකාරිත්වය “එකතු කරන්න”
(++) :: [t] -> [t] -> [t]
(x : xs) ++ ys = x : xs ++ ys
[] ++ ys = ys
infixr 5 ++
සංකේතවත් එකක් අනිකට සම්බන්ධව ගණනය [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 () = ()
තේරීම සහ අසාර්ථකත්වය සඳහා සහාය වන ආකලන මොනාඩ් වර්ග වර්ගයක් භාවිතා කිරීමෙන් වියුක්ත කළ හැකිය
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)
සහ failආකලන මොනාඩ් වල ශුන්‍ය මූලද්‍රව්‍යය අවශෝෂණය / විනාශ කිරීම වේ
_ =<< fail = fail
ඇතුලත නම්
guard (even p) >> return p
even pසත්‍ය නම්, එවිට ආරක්ෂකයා [()]විසින් >>දේශීය නියත ශ්‍රිතය නිපදවන අතර අර්ථ දැක්වීම අනුව
\ _ -> return p
ප්‍රති .ලයට අදාළ වේ (). අසත්‍ය නම්, ආරක්ෂකයා විසින් මොනාඩ්ගේ fail( []) ලැයිස්තුව නිපදවන අතර , එය ක්ලයිස්ලි ඊතලයක් යෙදීම සඳහා කිසිදු ප්‍රති result ලයක් ලබා නොදේ >>, එබැවින් මෙය pමඟ හැරේ.
රජයේ
කුප්‍රකට ලෙස, රාජ්ය ගණනය කිරීම් කේතනය කිරීම සඳහා මොනාඩ්ස් භාවිතා කරයි.
ඒ රාජ්ය සකසනය ශ්රිතයක් වේ
forall st t. st -> (t, st)
එය රාජ්‍යයක් සංක්‍රමණය කර stප්‍රති .ලයක් ලබා දෙයි t. මෙම රාජ්ය st දෙයක් විය හැක. කිසිවක්, ධජය, ගණන් කිරීම, අරාව, හැසිරවීම, යන්ත්‍රය, ලෝකය.
රාජ්ය සකසන වර්ගය සාමාන්යයෙන් හැඳින්වේ
type State st t = st -> (t, st)
රාජ්ය සකසනය monad මෙම 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, රාජ්ය මොනාඩ් වලට වඩා වියුක්ත කිරීමේ ක්රම :
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
class Monad m => Stateful m st | m -> st where
get :: m st
put :: st -> m ()
m -> stමොනාඩ් මත රාජ්ය වර්ගයේ ක්‍රියාකාරී යැපීමක් ප්‍රකාශ කරයි ; a , උදාහරණයක් ලෙස, රාජ්ය වර්ගය අද්විතීය ලෙස තීරණය කරයි .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 }
} }
ප්‍රකාශන-නැඹුරු වැඩසටහන්කරණයේදී (උදා: රස්ට්), බ්ලොක් එකක අවසාන ප්‍රකාශය එහි අස්වැන්න නියෝජනය කරයි. බන්ධන ක්රියාකරු සමහර විට “ක්‍රමලේඛගත කළ හැකි අර්ධ සළකුණක්” ලෙස හැඳින්වේ.
පුනරාවර්තන පාලන ව්‍යුහය ව්‍යුහාත්මක අත්‍යවශ්‍ය ක්‍රමලේඛනවල ප්රාථමිකයන් ඒකාකාරී ලෙස අනුකරණය කරනු ලැබේ
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.
ඒ functor 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)යනු homomorphism පන්තියේ සියලු 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
මෙම Kleisli ප්රවර්ගය ප්රවර්ග ක Cවන Kleisli ත්රිත්ව මගින් ලබා දෙන
<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)
දී morphism ලබා දෙන Haskගේ Kleisli ප්රවර්ගය
f* : T(X) -> T(Y)
(f =<<) :: m a -> m b
ක්ලයිස්ලි කාණ්ඩයේ සංයුතිය දීර් .Textension කිරීම අනුව ලබා දී ඇත
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
Monads ද Kleislian දීර්ඝ අනුව නොවේ අර්ථ හැක, නමුත් ස්වාභාවික පරිවර්තනය 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ලැයිස්තුව monad ය.
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
නමුත් වියුක්ත න්‍යායක් ක්‍රමලේඛනය සඳහා කිසියම් ප්‍රයෝජනයක් විය යුත්තේ ඇයි?
පිළිතුර සරල ය: පරිගණක විද්‍යා scientists යින් වශයෙන් අපි වියුක්ත කිරීම අගය කරමු ! අපි අතුරු මුහුණත මෘදුකාංග සංරචකයකට සැලසුම් කරන විට, එය ක්රියාත්මක කිරීම පිළිබඳව හැකි තරම් සුළු ප්‍රමාණයක් හෙළි කිරීමට අපට අවශ්‍යය . ක්රියාත්මක කිරීම බොහෝ විකල්පයන් සමඟ ප්රතිස්ථාපනය කිරීමට අපට අවශ්‍යය, එකම 'සංකල්පයේ' තවත් බොහෝ අවස්ථා. අපි බොහෝ වැඩසටහන් පුස්තකාල සඳහා සාමාන්‍ය අතුරු මුහුණතක් නිර්මාණය කරන විට, අප තෝරා ගන්නා අතුරු මුහුණතෙහි විවිධාකාර ක්රියාත්මක කිරීම් තිබීම ඊටත් වඩා වැදගත් ය. මොනාඩ් සංකල්පයේ සාමාන්‍ය භාවය අප බෙහෙවින් අගය කරන අතර, එයට හේතුව කාණ්ඩ න්යාය වියුක්ත බැවින් එහි සංකල්ප ක්‍රමලේඛනය සඳහා එතරම් ප්රයෝජනවත් වේ.
එසේ නම්, අප පහත ඉදිරිපත් කරන මොනාඩ් සාමාන්‍යකරණය කිරීම ද කාණ්ඩ න්‍යායට සමීප සම්බන්ධයක් ඇති බව කිසිසේත්ම අධිපති නොවේ. නමුත් අපගේ අරමුණ ඉතා ප්‍රායෝගික බව අපි අවධාරණය කරමු: එය 'වර්ගීකරණ න්යාය ක්රියාත්මක කිරීම' නොවේ, එය සංයුක්ත පුස්තකාල සැකසීමට වඩාත් පොදු ක්‍රමයක් සොයා ගැනීමයි. ගණිත ians යන් දැනටමත් අප වෙනුවෙන් බොහෝ කාර්යයන් කර තිබීම අපගේ වාසනාවකි!
ජෝන් හියුස් විසින් මොනාඩ්ස් සිට ඊතල දක්වා සාමාන්‍යකරණය කිරීම
