Это функция id с побочным эффектом вывода сообщения на экран. Ею можно пользоваться для отладки. На-
пример так можно вернуть значение и распечатать его:
echo :: Show a => a -> a
echo a = trace (show a) a
8.6 Композиция монад
Эта глава завершает наше путешествие в мире типов-монад. Мы начали наше знакомство с монадами с
композиции, мы определили класс Monad через класс Kleisli, который упрощал составление специальных
функций вида a -> m b. Тогда мы познакомились с самыми простыми типами монадами (списки и частично
определённые функции), потом мы перешли к типам посложнее, мы научились проводить вычисления с
состоянием. В этой главе мы рассмотрели самый важный тип монаду IO. Мне бы хотелось замкнуть этот
рассказ на теме композиции. Мы поговорим о композиции нескольких монад.
Если вы посмотрите в исходный код библиотеки transformers, то увидите совсем другое определение для
State:
type State s = StateT s Identity
newtype StateT s m a = StateT { runStateT :: s -> m (a,s) }
newtype Identity a = Identity { runIdentity :: a }
Но так ли оно далеко от нашего? Давайте разберёмся. Identity это тривиальный тип обёртка. Мы просто
заворачиваем значение в конструктор и ничего с ним не делаем. Вы наверняка сможете догадаться как опре-
делить экземпляры всех рассмотренных в этой главе классов для этого типа. Тип StateT больше похож на
наше определение для State, единственное отличие – это дополнительный параметр m в который завёрнут
результат функции обновления состояния. Если мы сотрём m, то получим наше определение. Это и сказано
в определении для State
type State s = StateT s Identity
Мы передаём дополнительным параметром в StateT тип Identity, который как раз ничего и не делает
с типом. Так мы получим наше исходное определение, но зачем такие премудрости? Такой тип принято
называть монадным трансформером (monad transformer). Он определяет композицию из нескольких монад в
данном случае одной из монад является State. Посмотрим на экземпляр класса Monad для StateT
instance (Monad m) => Monad (StateT s m) where
return a = StateT $ s -> return (s, a)
a >>= f = StateT $ s0 ->
runStateT a s0 >>= (b, s1) -> runStateT (f b) s1
В этом определении мы пропускаем состояние через сито методов класса Monad для типа m. В остальном
это определение ничем не отличается от нашего. Также определены и ReaderT, WriterT, ListT и MaybeT.
Ключевым классом для всех этих типов является класс MonadTrans:
class MonadTrans t where
lift :: Monad m => m a -> t m a
Этот тип позволяет нам заворачивать специальные значения типа m в значения типа t. Посмотрим на
определение для StateT:
instance MonadTrans (StateT s) where
lift m = StateT $ s -> liftM (,s) m
Композиция монад | 139
Напомню, что функция liftM это тоже самое , что и функция fmap, только она определена через методы
класса Monad. Мы создали функцию обновлнения состояния, которая ничего не делает с состоянием, а лишь
прицепляет его к значению.
Приведём простой пример применения трансформеров. Вернёмся к примеру FSM из предыдущей главы.
Предположим, что наш конечный автомат не только реагирует на действия, но и ведёт журнал, в который
записываются все поступающие на вход события. За переход состояний будет по прежнему отвечать тип State
только теперь он станет трансформером, для того чтобы включить воможность журналирования. За ведение
журнала будет отвечать тип Writer. Ведь мы просто накапливаем записи.
Интересно, что для добавления новой возможности нам нужно изменить лишь определение типа FSM и
функцию fsm, теперь они примут вид:
module FSMt where
import Control.Monad.Trans.Class
import Control.Monad.Trans.State
import Control.Monad.Trans.Writer
import Data.Monoid
type FSM s = StateT s (Writer [String]) s
fsm :: Show ev => (ev -> s -> s) -> (ev -> FSM s)
fsm transition e = log e >> run e
where run e = StateT $ s -> return (s, transition e s)
log e = lift $ tell [show e]
Все остальные функции останутся прежними. Сначала мы подключили все необходимые модули из биб-
лиотеки transformers. В подфункции log мы сохраняем сообщение в журнал, а в подфункции run мы вы-
полняем функцию перехода. Посмотрим, что у нас получилось:
*FSMt> let res = mapM speaker session
*FSMt> runWriter $ runStateT res (Sleep, Level 2)
(([(Sleep, Level 2),(Work, Level 2),(Work, Level 3),(Work, Level 2),
(Sleep, Level 2)],(Sleep, Level 3)),
[”Button”,”Louder”,”Quieter”,”Button”,”Louder”])
*FSMt> session
[Button, Louder, Quieter, Button, Louder]
Мы видим, что цепочка событий была успешно записана в журнал.
Для трансформеров с типом IO определён специальный класс:
class Monad m => MonadIO m where
liftIO :: IO a -> m a
Этот класс живёт в модуле Control.Monad.IO.Class. С его помощью мы можем выполнять IO-действия
ввнутри другой монады. Эта возможность бывает очень полезной. Вам она обязательно понадобится, если вы
начнёте писать веб-сайты на Haskell (например в happstack) или будете пользоваться библиотеками, которые
надстроены над C (например физический движок Hipmunk).
8.7 Краткое содержание
Наконец-то мы научились писать программы! Программы, которые можно исполнять за пределами ин-
терпретатора. Для этого нам пришлось познакомиться с типом IO. Экземпляр класса Monad для этого типа
интерпретируется специальным образом. Он вносит упорядоченность в выполнение программы. В нашем
статическом мире описаний появляются такие понятия как “сначала”, “затем”, “до” и “после”. Но они не
смогут нанести много вреда.
Вычисление операций с побочными эффектами разбивает программу на кадры. Но это не мешает нам
писать основные функции в чистом виде, подставляя их по мере необходимости в изменчивый мир побочных
эффектов с помощью методов из классов Functor, Applicative, Monad.
Мы узнали как в Haskell обстоят дела с такими типичными задачами мира побочных эффектов как
ввод/вывод, чтение/запись файлов, генерация случайных значений, выполнение внешних программ, ини-
циализация программ с помощью флагов. Также мы узнали о том, как обрабатываются специфические для
типа IO исключения.
140 | Глава 8: IO
8.8 Упражнения
Старайтесь свести присутствие функций с побочными эффектами к минимуму. Идеальный случай, когда
тип IO встречается только в функции main. Часто программы устроены более хитрым образом и функции
с побочными эффектами пытаются расползтись по всему коду. Но даже в этом случае программу можно
разделить на две части: в одной живут подлинные источники побочных эффектов, такие как чтение файлов,
генерация случайных значений, а в другой – чистые функции. Старайтесь устроить программу так, чтобы
она была максимально чистой. Чистые функции гораздо проще комбинировать, понимать, изменять.
• Это упражнение даёт вам возможность почувствовать преимущества чистого кода. Вспомните функ-
цию поиска корней методом неподвижной точки (этот пример встречался в главе о ленивых вычисле-
ниях). Напишите на основе этого примера программу, которая будет распечатывать решение и после-
довательность приближений. Последовательность приближений состоит из текущего значения корня
и расстоянии между корнями.
Напишите два варианта программы, в одном вы измените алгоритм так, чтобы печать происходила
