Тройка полезных монад

Внимание: перед тем как читать текст ниже, вы уже должны иметь представление о том, что такое монады. Если это не так, то прежде прочитайте вот этот пост!

Перед нами функция half:

И мы можем применить её несколько раз:

half . half $ 8 => 2 

Всё работает как и ожидалось. Но вот вы решили, что хорошо бы иметь лог того, что происходит с этой функцией:

half x = (x `div` 2, "Я только что располовинил  " ++ (show x) ++ "!") 

Что ж, отлично. Но что будет если вы теперь захотите применить half несколько раз?

half . half $ 8 

Вот то, что мы хотели бы, чтобы происходило:

Спойлер: автоматически так не сделается. Придётся всё расписывать ручками:

finalValue = (val2, log1 ++ log2)     where (val1, log1) = half 8           (val2, log2) = half val1 

Фу! Это ни капли не похоже на лаконичное

half . half $ 8 

А что, если у вас есть ещё функции, имеющие лог? Напрашивается такая схема: для каждой функции, возвращающей вместе со значением лог, мы бы хотели объединять эти логи. Это побочный эффект, а никто не силён в побочных эффектах так, как монады!

Монада Writer

Появляется монада Writer на белом коне
Монада Writer — крутая личность. «Не парься, чувак, я обработаю твои логи,» — говорит она. — «Возвращайся к своему чистому коду и выжми максимум под что-нибудь из Zeppelin!»

У каждого экземпляра Writer есть лог и возвращаемое значение:

data Writer w a = Writer { runWriter :: (a, w) } 

Writer позволяет нам писать код наподобие

half 8 >>= half 

Ну, или вы можете использовать <=< функцию, которая суть композиция функций для монад, чтобы получить:

half <=< half $ 8 

что чертовски близко к half . half $ 8. Круто!

Вы можете использовать tell, чтобы записать что-то в лог. А return передаст это значение в Writer. Вот наша обновлённая функция half:

half :: Int -> Writer String Int half x = do         tell ("I just halved " ++ (show x) ++ "!")         return (x `div` 2) 

Она возвращает Writer:

И мы можем использовать runWriter, чтобы извлечь из него значение:

runWriter $ half 8 => (4, "I just halved 8!") 

Но самый клёвый момент, это то, что теперь мы можем связать вызовы half в цепочку, используя >>=:

runWriter $ half 8 >>= half => (2, "I just halved 8!I just halved 4!") 

Вот что происходит:

Магическим образом >>= знает, как объединить два Writer’а, так что нам нет нужды писать самостоятельно какой бы то ни было нудный код! Вот полное определение >>=:

Точно такой же шаблонный код мы ранее писали сами, а теперь эту обязанность взяла на себя >>=. Клёво! Мы так же используем функцию return, которая принимает значение и помещает его в монаду:

return val = Writer (val, "") 

(Замечание: это определение почти верное. На самом деле монада Writer позволяет нам использовать любой Monoid в качестве лога, а не одни только строки. Я тут упростил слегка.)

Спасибо тебе, монада Writer!

Монада Reader

Допустим, вы хотите передать какие-то настройки в множество функций. Просто используйте монаду Reader:

Она позволит вам передать ваше значение всем функциям, скрыв сам механизм передачи за кулисами. Например:

greeter :: Reader String String greeter = do     name <- ask     return ("hello, " ++ name ++ "!") 

greeter возвращает монаду Reader:

Вот её определение:

data Reader r a = Reader {  runReader :: r -> a } 

Reader всегда был перебежчиком. Тёмной лошадкой. Reader другой, потому что он позволяет нам обрабатывать функцию, что смущает при его рассмотрении. Но мы с вами понимаем, что можем использовать runReader, чтобы извлечь эту функцию:

И можем передать этой функции некое состояние, которое потом используется в greeter:

runReader greeter $ "adit" => "hello, adit!"  

таким образом, когда вы используете >>=, назад вы должны получить Reader. Когда вы передадите в него состояние, то оно будет передано всем функциям, содержащимся в этой монаде.

m >>= k  = Reader $ \r -> runReader (k (runReader m r)) r 

Reader всегда был несколько комплексным. Это вообще его лучшее качество.
return помещает значение в Reader:

return a = Reader $ \_ -> a 

И, наконец, ask возвращает вам обратно состояние, которое вы передали:

ask = Reader $ \x -> x  

Хотите провести с Reader’ом больше времени? Врубите панк-рок и взгляните на более длинный пример.

Монада State

Монада State — это более впечатлительный лучший друг монады Reader:

Она в точности тоже самое, что и монада Reader, но с её помощью вы можете не только читать, но и писать!
Вот определение State:

State s a = State { runState :: s -> (a, s) }  

Вы можете получить состояние с помощью get или изменить его с помощью put. Вот пример:

greeter :: State String String greeter = do     name <- get     put "tintin"     return ("hello, " ++ name ++ "!")   runState greeter $ "adit" => ("hello, adit!", "tintin") 

Мило! Если Reader был с характером«тебе-меня-не-изменить», то State наоборот стремится к отношениям и сама готова меняться.
Определение State монады выглядит очень похоже на определение монады Reader:
return:

return a = State $ \s -> (a, s) 

>>=:

m >>= k = State $ \s -> let (a, s') = runState m s                          in runState (k a) s' 

Заключение

Writer. Reader. State. Сегодня вы добавили три мощных оружия в свой Haskell-арсенал. Используйте их с умом.

От переводчика: я буду бесконечно признательна за любые замечания в личку, которые помогут улучшить качество этого перевода.