Читать онлайн «Изучай Haskell во имя добра!». Страница 86

Случайность и монада State

В начале этого раздела мы говорили о том, что генерация случайных чисел может иногда быть неуклюжей. Каждая функция, использующая случайность, принимает генератор и возвращает случайное число вместе с новым генератором, который должен затем быть использован вместо прежнего, если нам нужно сгенерировать ещё одно случайное число. Монада State намного упрощает эти действия.

Функция random из модуля System.Random имеет следующий тип:

random :: (RandomGen g, Random a) => g –> (a, g)

Это значит, что она берёт генератор случайных чисел и производит случайное число вместе с новым генератором. Нам видно, что это вычисление с состоянием, поэтому мы можем обернуть его в конструктор newtype State при помощи функции state, а затем использовать его в качестве монадического значения, чтобы передача состояния обрабатывалась за нас:

import System.Random

import Control.Monad.State

randomSt :: (RandomGen g, Random a) => State g a

randomSt = state random

Поэтому теперь, если мы хотим подбросить три монеты (True – это «решка», а False – «орёл»), то просто делаем следующее:

import System.Random

import Control.Monad.State

threeCoins :: State StdGen (Bool, Bool, Bool)

threeCoins = do

   a <– randomSt

   b <– randomSt

   c <– randomSt

   return (a, b, c)

Функция threeCoins – это теперь вычисление с состоянием, и после получения исходного генератора случайных чисел она передаёт этот генератор в первый вызов функции randomSt, которая производит число и новый генератор, передаваемый следующей функции, и т. д. Мы используем выражение return (a, b, c), чтобы представить значение (a, b, c) как результат, не изменяя самый последний генератор. Давайте попробуем:

ghci> runState threeCoins (mkStdGen 33)

((True,False,True),680029187 2103410263)

Теперь выполнение всего, что требует сохранения некоторого состояния в промежутках между шагами, в самом деле стало доставлять значительно меньше хлопот!

К этому времени вы знаете, что монада Maybe используется, чтобы добавить к значениям контекст возможной неудачи. Значением может быть Just <нечто> либо Nothing. Как бы это ни было полезно, всё, что нам известно, когда у нас есть значение Nothing, – это состоявшийся факт некоей неудачи: туда не втиснуть больше информации, сообщающей нам, что именно произошло.

И тип Either e a позволяет нам включать контекст возможной неудачи в наши значения. С его помощью тоже можно прикреплять значения к неудаче, чтобы они могли описать, что именно пошло не так, либо предоставить другую полезную информацию относительно ошибки. Значение типа Either e a может быть либо значением Right (правильный ответ и успех) либо значением Left (неудача). Вот пример:

ghci> :t Right 4

Right 4 :: (Num t) => Either a t

ghci> :t Left "ошибка нехватки сыра"

Left "ошибка нехватки сыра" :: Either [Char] b

Это практически всего лишь улучшенный тип Maybe, поэтому имеет смысл, чтобы он был монадой. Он может рассматриваться и как значение с добавленным контекстом возможной неудачи, только теперь при возникновении ошибки также имеется прикреплённое значение.

Его экземпляр класса Monad похож на экземпляр для типа Maybe и может быть обнаружен в модуле Control.Monad.Error[15]:

instance (Error e) => Monad (Either e) where

   return x = Right x

   Right x >>= f = f x

   Left err >>= f = Left err

   fail msg = Left (strMsg msg)

Функция return, как и всегда, принимает значение и помещает его в минимальный контекст по умолчанию. Она оборачивает наше значение в конструктор Right, потому что мы используем его для представления успешных вычислений, где присутствует результат. Это очень похоже на определение метода return для типа Maybe.

Оператор >>= проверяет два возможных случая: Left и Right. В случае Right к значению внутри него применяется функция f, подобно случаю Just, где к его содержимому просто применяется функция. В случае ошибки сохраняется значение Left вместе с его содержимым, которое описывает неудачу.

Экземпляр класса Monad для типа Either e имеет дополнительное требование. Тип значения, содержащегося в Left, – тот, что указан параметром типа e, – должен быть экземпляром класса Error. Класс Error предназначен для типов, значения которых могут действовать как сообщения об ошибках. Он определяет функцию strMsg, которая принимает ошибку в виде строки и возвращает такое значение. Хороший пример экземпляра Error – тип String! В случае со String функция strMsg просто возвращает строку, которую она получила:

ghci> :t strMsg

strMsg :: (Error a) => String –> a

ghci> strMsg "Бум!" :: String

"Бум!"

Но поскольку при использовании типа Either для описания ошибки мы обычно задействуем тип String, нам не нужно об этом сильно беспокоиться. Когда сопоставление с образцом терпит неудачу в нотации do, то для оповещения об этой неудаче используется значение Left.

Вот несколько практических примеров:

ghci> Left "Бум" >>= \x –>return (x+1)

Left "Бум"

ghci> Left "Бум " >>= \x –> Left "нет пути!"

Left "Бум "

ghci> Right 100 >>= \x –> Left "нет пути!"

Left "нет пути!"

Когда мы используем операцию >>=, чтобы передать функции значение Left, функция игнорируется и возвращается идентичное значение Left. Когда мы передаём функции значение Right, функция применяется к тому, что находится внутри, но в данном случае эта функция всё равно произвела значение Left!

Использование монады Error очень похоже на использование монады Maybe.

ПРИМЕЧАНИЕ. В предыдущей главе мы использовали монадические аспекты типа Maybe для симуляции приземления птиц на балансировочный шест канатоходца. В качестве упражнения вы можете переписать код с использованием монады Error, чтобы, когда канатоходец поскальзывался и падал, вы запоминали, сколько птиц было на каждой стороне шеста в момент падения.

В этом разделе мы изучим несколько функций, которые работают с монадическими значениями либо возвращают монадические значения в качестве своих результатов (или и то, и другое!). Такие функции обычно называют монадическими. В то время как некоторые из них будут для вас совершенно новыми, другие являются монадическими аналогами функций, с которыми вы уже знакомы – например, filter и foldl. Ниже мы рассмотрим функции liftM, join, filterM и foldM.

Когда мы начали своё путешествие на верхушку Горы Монад, мы сначала посмотрели на функторы, предназначенные для сущностей, которые можно отображать. Затем рассмотрели улучшенные функторы – аппликативные, которые позволяют нам применять обычные функции между несколькими аппликативными значениями, а также брать обычное значение и помещать его в некоторый контекст по умолчанию. Наконец, мы ввели монады как улучшенные аппликативные функторы, которые добавляют возможность тем или иным образом передавать эти значения с контекстом в обычные функции.

Итак, каждая монада – это аппликативный функтор, а каждый аппликативный функтор – это функтор. Класс типов Applicative имеет такое ограничение класса, ввиду которого наш тип должен иметь экземпляр класса Functor, прежде чем мы сможем сделать для него экземпляр класса Applicative. Класс Monad должен иметь то же самое ограничение для класса Applicative, поскольку каждая монада является аппликативным функтором – однако не имеет, потому что класс типов Monad был введён в язык Haskell задолго до класса Applicative.

Но хотя каждая монада – функтор, нам не нужно полагаться на то, что у неё есть экземпляр для класса Functor, в силу наличия функции liftM. Функция liftM берёт функцию и монадическое значение и отображает монадическое значение с помощью функции. Это почти одно и то же, что и функция fmap! Вот тип функции liftM:

liftM :: (Monad m) => (a –> b) –> m a –> m b

Сравните с типом функции fmap:

fmap :: (Functor f) => (a –> b) –> f a –> f b

Если экземпляры классов Functor и Monad для типа подчиняются законам функторов и монад, между этими двумя нет никакой разницы (и все монады, которые мы до сих пор встречали, подчиняются обоим). Это примерно как функции pure и return, делающие одно и то же, – только одна имеет ограничение класса Applicative, тогда как другая имеет ограничение Monad.