Haskell/Monad transformers: различия между версиями

К этому моменту вы должны были предварительно уяснить понятие монады, а также то, что различные монады используются еще для: <code>IO</code> для "«нечистых"» функций, <code>Maybe</code> для значений, которые могут быть или нет, и так далее.

С помощью монад, обеспечивающих такую полезную функциональность общего назначения, очень естественно, что порой мы хотели бы использовать возможности ''нескольких'' монад сразу -- — например, функция, которая использует и <code>IO</code>, и обработку исключений <code>Maybe</code>. Конечно, мы можем использовать такой тип как <code>IO (Maybe a)</code>, но это заставляет нас делать сопоставление с образцом в <code>do</code>-блоках, чтобы извлечь необходимые значения: однако, фишка ''монад'' была также в том, чтобы избавиться от этого.

Типичная стратегия -- — заставить пользователя ввести пароль не короче минимальной длины, и по крайней мере одну букву, одну цифру (и с другими подобными раздражающими требованиями).

В первую очередь, <code>getPassword</code> является <code>IO</code>-функцией, так как ей необходимо получить ввод от пользователя, ну и он не всегда будет возвращаться. Мы также используем <code>Maybe</code>, так как мы намерены возвращать <code>Nothing</code> в случае, если пароль не проходит условие <code>isValid</code>. Заметим, однако, что мы фактически не будем использовать <code>Maybe</code> здесь как монаду: <code>do</code>-блок находится в <code>IO</code>-монаде, и нам просто повезло получить <code>return</code> с <code>Maybe</code>-значением внутри.

<code>newtype</code> -- — это просто более эффективная альтернатива обычным декларациям <code>data</code> на случаи, когда есть только один конструктор. Так, <code>MaybeT</code> является конструктором типа, параметризованного более <code>m</code>, с конструктором данных, который также называется <code>MaybeT</code> и удобной функцией доступа <code>runMaybeT</code>, с помощью которой мы можем получить доступ к базовому (внутреннему) представлению.

<code>return</code>  осуществляется  с помощью <code>Just</code>, который вставляет (не указанное из-за частичного применения значение) в  монаду <code>Maybe</code>, затем общий  <code>return</code>, который в свою очередь вводит (полученное значение) в  <code>m</code>  (чем бы это ни было) и затем  конструктор <code>MaybeT</code>.

Также возможно (хотя менее приятно читается) написать  <code>return = MaybeT . return . return</code>.

Как и у всех монад, оператор связывания <code>bind</code> является сердцем трансформера, и самым важным фрагментом кода для понимания того, как он работает.  Как всегда, полезно иметь в виду сигнатуру типов.  Типом  оператора связывания <code>bind</code> для монады <code>MaybeT</code>  будет:

Последний класс, <code>MonadTrans</code>, реализует (обеспечивает) функцию <code>lift</code>, которая очень полезна для того, чтобы взять функции из монады <code>m</code> и поднять (принести) их внутрь монады <code>MaybeT m</code>, так чтобы мы смогли использовать их в <code>do</code>-блоке внутри монады <code>MaybeT m</code>.

Отметим как мы используем <code>lift</code>, чтобы поднять функции <code>getLine</code> и <code>putStrLn</code> вовнутрь монады <code>MaybeT IO</code>. Также, так как <code>MaybeT IO</code> является воплощением <code>MonadPlus</code>, проверка правильности пароля может быть осуществлена выражением <code>guard</code>, который вернет <code>mzero</code> (т.е.то есть <code>IO Nothing</code>) в случае плохого пароля.

И кстати, с помощью <code>MonadPlus</code> стало очень просто спрашивать у пользователя правильный пароль ''до бесконечности''

Все же, не все трансформеры связаны с базовой монадой таким образом. Монады <code>Writer</code>, <code>Reader</code>, <code>State</code> и <code>Cont</code> объединяет то, что в отличие от базовых монады в примерах выше, они не имеют ни нескольких конструкторов, ни конструкторов с несколькими аргументами. По этой причине, у них есть функции <tt>run...</tt>, которые действуют как простые развертыватели (unwrappers) аналогично соотвественнымсоответственным <tt>run...T</tt> из версий трансформера. В приведенной ниже таблице показаны результаты типов функций <tt>run...</tt> и <tt>run...T</tt> в каждом конкретном случае, что может рассматриваться как типы обернутые базовой и трансформированной монадой соответственно.

!|Transformer

!|Original Type<br/><small>("«wrapped"» by base)</small>

!|Combined Type<br/><small>("«wrapped"» by transformed)</small>

Первое, на что нужно обратить внимание, это то, что базовые монады нигде не было видно в комбинированной типов. Это очень естественно, так как без конструкторы интересны (например, те для Может быть, или списки) нет никаких причин, чтобы сохранить базовый тип монады после разворачивания преобразованной монады. . Кроме того, в трех последних случаях у нас есть функция типа завернутые StateT , например, превращает государственные преобразования функций вида с -> (A, S) в государственно-преобразования функций вида с -> M ( , с) , так что только тип результата функции завернутые идет во внутренний монады. ReaderT аналогична, но не ContT : в связи с семантикой Cont ( продолжение монады) результат обоих типов завернутые функции и ее функциональное Аргумент должен быть таким же, так что трансформатор ставит как во внутреннюю монады. Что эти примеры показывают, что в целом нет никакой волшебной формулы для создания трансформатора версия монады-формы каждого трансформера, зависит от того, что имеет смысл в контексте его не-трансформатор типа.

<code>liftM</code> применяет функцию <code>(a1 -> r)</code> к значению в рамках (внутри) монады <code>m</code>. Если вы предпочитаете бесточечную запись, она может превратить обычную функцию в такую, которая действует внутри <code>m</code> -- — и ''это'' как раз то, что подразумевается под поднятием в монаду.

С <code>liftM</code> мы увидели, что сущность поднятия -- — перефразируя документацию -- — в продвижении чего-то в монаду. Функция <code>lift</code>, доступная для всех монадных трансформеров, выполняет разный тип поднятия: она продвигает вычисление из внутренней монады в комбинированную монаду. Функция <code>lift</code> определена как единственный метод класса <code>MonadTrans</code> в {{Haskell lib|p=transformers|v=latest|Control|Monad|Trans|Class}}.

<code>liftIO</code> может быть удобен, когда у нас множестов трансформеров помещены друг за другом (как в стек) в одну комбинированную монаду. В подобных случаях, <code>IO</code> будет всегда самой внутренней монадой, и таким образом обычно нужен более чем один <code>lift</code>, чтобы поднять <code>IO</code>-значения на вершину стека. <code>liftIO</code>, однако, определен для воплощений таким образом, что позволяет нам поднять <code>IO</code>-значение из произвольной глубины, написав функцию лишь единожды.

Мы начинаем с монадическим значением внутренней монады -- — средним слоем, если вы предпочитаете аналогию с сэндвичем. Используя оператор <code>bind</code> и конструктор типа для базовой монады, мы плавно сдвигаем (скатываем, намазываем ??) нижний слой (базовую монаду) под средний слой. В конце, мы помещаем верхний срез нашего сэндвича с помощью конструктора <code>MaybeT</code>. Таким образом, используя фнукцию <code>lift</code>, мы трансформировали нижний кусок начинки сэндвича в подлинно трехслойный монадический сэндвич. Отметим, что как в реализации класса <code>Monad</code>, и оператор <code>bind</code>, и общий (основной) оператор <code>return</code> работают в границах внутренней монады.

=== Трансформер List ===

Реализация монады <code>ListT m</code> поразительно похожа на свою "«кузину"», монаду списков. Мы делаем те же самые операции

=== Трансформер State ===

Как и монада <code>State</code> могла быть построена определением <code>newtype State s a = State { runState :: (s -> (a,s)) }</code> <ref>В версии пакета <tt>mtl</tt> ранее 2.0.0.0, так и ''было'' построено. В настоящее время, однако, <code>State s</code> реализована как синоним типа для <code>StateT s Identity</code>.</ref> Трансформер <code>StateT</code> создан определением

Мы также хотим декларировать все комбинированные монады, которые используют трансформер <code>StateT</code>, как воплощения

Последним шагом сделаем наш монадный трансформер полностью интегрированным с классом монад Haskell'а --Haskell’а — для этого сделаем <code>StateT s</code> воплощением класса <code>MonadTrans</code>, обеспечив функцию <code>lift</code>:

Функция <code>lift</code> создает функцию, изменяющую состояние, <code>StateT</code>, которая связывает вычисление во внутренней монаде с функцией, пакующей результат со входным состоянием. Результат в том, если для воплощения мы применяем

StateT к монаде the List, функция, которая возвращает список (т.е.то есть, вычисление в монаде List) может быть поднято вовнутрь

<code>StateT&nbsp;s&nbsp;[]</code>, где оно станет функцией, которая возвращает <code>StateT&nbsp;(s&nbsp;->&nbsp;[(a,s)])</code>. Таким образом, поднятое вычисление производит ''множественные'' пары (значение, состояние) из его внутреннего состояния. Эффект выразится в "«разветвлении"» вычисления в StateT, создавая разные ветви для разных значений в списке, возращенном поднятой функцией. Разумеется, применяя <code>StateT</code> к разным монадам, получим разную семантику функции <code>lift</code>.

== Благодарности ==