Пользователь
0,0
рейтинг
2 июля 2013 в 09:17

Разработка → Тройка полезных монад перевод

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

Перед нами функция 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-арсенал. Используйте их с умом.

От переводчика: я буду бесконечно признательна за любые замечания в личку, которые помогут улучшить качество этого перевода.
Перевод: Aditya Bhargava
@AveNat
карма
209,0
рейтинг 0,0
Реклама помогает поддерживать и развивать наши сервисы

Подробнее
Реклама

Самое читаемое Разработка

Комментарии (5)

  • +3
    Замечательная статья. Читал ещё в оригинале.

    Будете переводить другие статьи с того сайта?
    • 0
      Пока не знаю ещё. Просто очень много всего интересного вокруг, что хотелось бы перевести (в первую очередь, чтобы самой как следует вникнуть).
  • 0
    Большое спасибо вам за переводы. Благодарю еще раз.
    • 0
      Вам спасибо за тёплые слова ^_^
  • 0
    Хоть и выучил эти монады достаточно давно (привет, LYAHFGG), все равно прочитал с удовольствием. Хороший перевод, спасибо.

Только зарегистрированные пользователи могут оставлять комментарии. Войдите, пожалуйста.