Миран Липовача - Изучай Haskell во имя добра!

Итак, при использовании операции >>=мы как бы «склеиваем» друг с другом два вычисления, обладающих состоянием. Второе вычисление скрыто внутри функции, которая принимает результат предыдущего вычисления. Поскольку функции popи pushуже являются вычислениями с состоянием, легко обернуть их в обёртку State:

import Control.Monad.State

pop :: State Stack Int

pop = state $ \(x:xs) –> (x, xs)

push :: Int –> State Stack ()

push a = state $ \xs –> ((), a:xs)

Обратите внимание, как мы задействовали функцию state, чтобы обернуть функцию в конструктор newtype State, не прибегая к использованию конструктора значения Stateнапрямую.

Функция pop– уже вычисление с состоянием, а функция pushпринимает значение типа Intи возвращает вычисление с состоянием. Теперь мы можем переписать наш предыдущий пример проталкивания числа 3в стек и выталкивания двух чисел подобным образом:

import Control.Monad.State

stackManip :: State Stack Int

stackManip = do

push 3

a <���– pop

pop

Видите, как мы «склеили» проталкивание и два выталкивания в одно вычисление с состоянием? Разворачивая его из обёртки newtype, мы получаем функцию, которой можем предоставить некое исходное состояние:

ghci> runState stackManip [5,8,2,1]

(5,[8,2,1])

Нам не требовалось привязывать второй вызов функции popк образцу a, потому что мы вовсе не использовали этот образец. Значит, это можно было записать вот так:

stackManip :: State Stack Int

stackManip = do

push 3

pop

pop

Очень круто! Но что если мы хотим сделать что-нибудь посложнее? Скажем, вытолкнуть из стека одно число, и если это число равно 5, просто протолкнуть его обратно в стек и остановиться. Но если число не равно 5, вместо этого протолкнуть обратно 3и 8. Вот он код:

stackStuff :: State Stack ()

stackStuff = do

a <���– pop

if a == 5

then push 5

else do

push 3

push 8

Довольно простое решение. Давайте выполним этот код с исходным стеком:

ghci> runState stackStuff [9,0,2,1,0] ((),[8,3,0,2,1,0])

Вспомните, что выражения doвозвращают в результате монадические значения, и при использовании монады Stateодно выражение doявляется также функцией с состоянием. Поскольку функции stackManipи stackStuffявляются обычными вычислениями с состоянием, мы можем «склеивать» их вместе, чтобы производить дальнейшие вычисления с состоянием:

moreStack :: State Stack ()

moreStack = do

a <���– stackManip

if a == 100

then stackStuff

else return ()

Если результат функции stackManipпри использовании текущего стека равен 100, мы вызываем функцию stackStuff; в противном случае ничего не делаем. Вызов return ()просто сохраняет состояние как есть и ничего не делает.

Модуль Control.Monad.Stateопределяет класс типов под названием MonadState, в котором присутствуют две весьма полезные функции: getи put. Для монады Stateфункция getреализована вот так:

get = state $ \s –> (s, s)

Она просто берёт текущее состояние и представляет его в качестве результата.

Функция putпринимает некоторое состояние и создаёт функцию с состоянием, которая заменяет им текущее состояние:

put newState = state $ \s –> ((), newState)

Поэтому, используя их, мы можем посмотреть, чему равен текущий стек, либо полностью заменить его другим стеком – например, так:

stackyStack :: State Stack ()

stackyStack = do

stackNow <���– get

if stackNow == [1,2,3]

then put [8,3,1]

else put [9,2,1]

Также можно использовать функции getи put, чтобы реализовать функции popи push. Вот определение функции pop:

pop :: State Stack Int

pop = do

(x:xs) <���– get

put xs

return x

Мы используем функцию get, чтобы получить весь стек, а затем – функцию put, чтобы новым состоянием были все элементы за исключением верхнего. После чего прибегаем к функции return, чтобы представить значение xв качестве результата.

Вот определение функции push, реализованной с использованием getи put:

push :: Int –> State Stack ()

push x = do

xs <���– get

put (x:xs)

Мы просто используем функцию get, чтобы получить текущее состояние, и функцию put, чтобы установить состояние в такое же, как наш стек с элементом xна вершине.

Стоит проверить, каким был бы тип операции >>=, если бы она работала только со значениями монады State:

(>>=) :: State s a –> (a –> State s b) –> State s b

Видите, как тип состояния sостаётся тем же, но тип результата может изменяться с aна b? Это означает, что мы можем «склеивать» вместе несколько вычислений с состоянием, результаты которых имеют различные типы, но тип состояния должен оставаться тем же. Почему же так?.. Ну, например, для типа Maybeоперация >>=имеет такой тип:

(>>=) :: Maybe a –> (a –> Maybe b) –> Maybe b

Логично, что сама монада Maybeне изменяется. Не имело бы смысла использовать операцию >>=между двумя разными монадами. Для монады Stateмонадой на самом деле является State s, так что если бы этот тип sбыл различным, мы использовали бы операцию >>=между двумя разными монадами.

В начале этого раздела мы говорили о том, что генерация случайных чисел может иногда быть неуклюжей. Каждая функция, использующая случайность, принимает генератор и возвращает случайное число вместе с новым генератором, который должен затем быть использован вместо прежнего, если нам нужно сгенерировать ещё одно случайное число. Монада 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)