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 তীর যে একটি মান প্রচার করে tকীটাণুজাতীয় প্রসঙ্গ মধ্যে m। এক্সটেনশন বা ক্লাইসলি অ্যাপ্লিকেশন কোনও গণনার ফলাফলের জন্য =<<ক্লেস্লি তীর প্রয়োগ করে ।a -> m bm a
Kleisli রচনাটি <=< এক্সটেনশনের ক্ষেত্রে সংজ্ঞায়িত করা হয়
(<=<) :: 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, এমন গণনা যা "ব্যর্থ" হতে পারে। বিকল্প monad সংজ্ঞায়িত করা হয়
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 :
এবং এর যোগমূলক মনোয়েড অপারেশন "সংযোজন"
(++) :: [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
কারণ প্রতিটি মোনাদই কেবল ফান্টেক্টর নয়, প্রতিটি আবেদনকারীই একটি ফান্টেক্টর এবং প্রতিটি মনাদ একটি আবেদনকারীও।
তালিকা monad ব্যবহার করে, আবশ্যক সিউডোকোড
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
)
)
স্বরলিপি এবং মনাদ বোঝাপড়া নেস্টেড বাইন্ড এক্সপ্রেশনগুলির জন্য সিনট্যাকটিক চিনি। বাইন্ড অপারেটর স্থানীয় নাম বাঁধার জন্য monadic ফলাফল ব্যবহার করা হয়।
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
যেখানে ইউনিট টাইপ বা "খালি tuple"
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এবং <|>একটি monoid গঠন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( []) তৈরি করে , যা ক্লাইসলি তীর প্রয়োগের জন্য কোনও ফল দেয় না >>, তাই 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, ওভার বিমূর্ততা পদ্ধতি stateful 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)
ইউনিট প্রকারের সাথে voidসি তে অ্যানালগ্যালি ব্যবহৃত হয় with
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
আই / ও ওয়ার্ল্ড স্টেট প্রসেসর মোনাড হ'ল খাঁটি হাস্কেল এবং বাস্তব জগতের ফাংশনাল ডেনোটেটিভ এবং অপরিহার্য অপারেশনাল সিনটিক্সের মিলন। প্রকৃত কঠোর বাস্তবায়নের ঘনিষ্ঠ অ্যানালগ:
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)
এমন একটি ফাংশন যা একটি বিশ্বকে রূপান্তরিত করে।
উপসংহার
বিভাগ whiches বস্তু Haskell, ধরনের এবং whiches morphisms Haskell, ধরনের, "দ্রুত এবং আলগা", বিভাগ মধ্যে ফাংশন হয় Hask।
একজন functor Tএকটি বিভাগ থেকে একটি ম্যাপিং হয় Cএকটি বিভাগ থেকে D; মধ্যে Cএকটি বস্তুর প্রতিটি বস্তুর জন্যD
Tobj : Obj(C) -> Obj(D)
f :: * -> *
এবং প্রতিটি আকারের জন্য Cএকটি আকারে mD
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, _*>
একটি endofunctor এর
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একটি endofunctor এর
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
তবে কেন একটি তত্ত্ব এত বিমূর্তের প্রোগ্রামিংয়ের জন্য কোনও উপযোগী হওয়া উচিত?
উত্তরটি সহজ: কম্পিউটার বিজ্ঞানী হিসাবে, আমরা বিমূর্তির মূল্য ! যখন আমরা কোনও সফ্টওয়্যার উপাদানটিতে ইন্টারফেসটি ডিজাইন করি, আমরা এটি বাস্তবায়ন সম্পর্কে যতটা সম্ভব কম তা প্রকাশ করতে চাই । আমরা বাস্তবের অনেকগুলি বিকল্প, একই 'ধারণার' অনেকগুলি 'উদাহরণ' দিয়ে প্রতিস্থাপন করতে সক্ষম হতে চাই। যখন আমরা অনেকগুলি প্রোগ্রাম লাইব্রেরিতে জেনেরিক ইন্টারফেস ডিজাইন করি, তখন আমাদের ইন্টারফেসটির বিভিন্ন ধরণের বাস্তবায়ন হওয়া আরও বেশি গুরুত্বপূর্ণ implement এটি মোনাড ধারণার সাধারণতা যা আমরা এত বেশি মূল্যবান, কারণ শ্রেণি তত্ত্বটি এত বিমূর্ত যে এর ধারণাগুলি প্রোগ্রামিংয়ের জন্য এত কার্যকর।
তবে এটি খুব কমই আশ্চর্যজনক যে, আমরা নীচে উপস্থাপিত মনাদগুলির সাধারণীকরণের বিভাগীয় তত্ত্বের সাথে নিবিড় সংযোগ রয়েছে। তবে আমরা জোর দিয়ে বলছি যে আমাদের উদ্দেশ্যটি অত্যন্ত ব্যবহারিক: এটি 'বিভাগের তত্ত্বটি বাস্তবায়ন' নয়, এটি সংযুক্তি গ্রন্থাগারগুলির কাঠামোগত গঠনের আরও সাধারণ উপায় খুঁজে বের করা। এটি কেবল আমাদের সৌভাগ্য যে গণিতবিদরা ইতিমধ্যে আমাদের জন্য অনেক কাজ করেছেন!
থেকে তীর থেকে Generalising Monads জন হিউজেস দ্বারা
