тл; д-р
{-# 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 $
з точки зору застосування примітивної функції Haskell 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є його правою та лівою тотожністю.
Клейслі потрійний
У програмуванні монада - це конструктор типу функтора з екземпляром класу типу монада. Існує кілька рівнозначних варіантів визначення та реалізації, кожен з яких має дещо різні інтуїції щодо абстракції монади.
Функтор - це тип конструктора fтипу * -> *з екземпляром класу типу функтор.
{-# 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 =<<
Ідентичність Клейла return є Клейл стрілок , яка сприяє значенням tв монадичну контексті m. Додаток Extension або Kleisli =<< застосовує стрілку Kleisli 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 :
та його додаткова моноїдна операція "додавати"
(++) :: [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)
_ =<< [] = []
Розширення =<<об'єднує ++всі списки, [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 = []
При визначенні класу типу монада замість розширення =<<стандарт Haskell використовує його фліп, оператор зв'язування>>= .
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" ,
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( []), який не дає результату для застосування стрілки Клейслі >>, тому це pпропускається.
Держава
Ганебно монади використовуються для кодування обчислень.
Стан процесора є функцією
forall st t. st -> (t, st)
що переходить у стан stі дає результат t. Стан st може бути що завгодно. Нічого, прапор, кількість, масив, ручка, машина, світ.
Зазвичай називають тип процесорів стану
type State st t = st -> (t, st)
Монада державного процесора - це добрий * -> *функтор State st. Стрілки Клейслі монади державного процесора - це функції
forall st a b. a -> (State st) b
У канонічному Haskell визначається лінива версія монади стану процесора
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декларує функціональну залежність типу держави stвід монади m; наприклад, що State t, наприклад, визначатиме тип стану tоднозначно.
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 }
} }
Як і в програмі, орієнтованому на експресію (наприклад, Rust), остання заява блоку представляє його вихід. Оператор прив'язки іноді називають «програмованою крапкою з комою».
Примітиви структури управління ітерацією від структурованого імперативного програмування імітуються монадно
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
Або, принаймні, слід.
Підпис типу програми Haskell
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)є класом гомоморфізму всіх морфізмів 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
Але чому теорія настільки абстрактна повинна бути корисною для програмування?
Відповідь проста: як комп'ютерні працівники, ми цінуємо абстракцію ! Коли ми розробляємо інтерфейс до програмного компонента, ми хочемо, щоб він якомога менше розкривав про реалізацію. Ми хочемо мати можливість замінити реалізацію багатьма альтернативами, багатьма іншими "екземплярами" тієї ж "концепції". Коли ми розробляємо загальний інтерфейс для багатьох бібліотек програм, ще важливішим є те, що обраний нами інтерфейс має різноманітні реалізації. Це загальне поняття монади, яке ми цінуємо так високо, тому що теорія категорій настільки абстрактна, що її концепції настільки корисні для програмування.
Тож навряд чи дивується те, що узагальнення монад, які ми представляємо нижче, також має тісний зв’язок із теорією категорій. Але ми підкреслюємо, що наша мета дуже практична: це не «впровадження теорії категорій», а пошук більш загального способу структури бібліотек-комбінаторів. Це просто наше щастя, що математики вже зробили багато роботи за нас!
від генералізації монадів до стрілок Джона Х'юза
