Не бойтесь! Монада чтения на самом деле не так уж сложна и имеет очень простую в использовании утилиту.
Есть два способа приблизиться к монаде: мы можем спросить
- Что монада делать ? Какими операциями он оборудован? Для чего это?
- Как реализована монада? Откуда это возникает?
С первого подхода монада читателя - это некий абстрактный тип
data Reader env a
такой, что
-- Reader is a monad
instance Monad (Reader env)
-- and we have a function to get its environment
ask :: Reader env env
-- finally, we can run a Reader
runReader :: Reader env a -> env -> a
Итак, как нам это использовать? Что ж, монада читателя хороша для передачи (неявной) информации о конфигурации посредством вычислений.
Каждый раз, когда у вас есть «константа» в вычислении, которая вам нужна в различных точках, но на самом деле вы хотите иметь возможность выполнять одно и то же вычисление с разными значениями, тогда вам следует использовать монаду чтения.
Монады чтения также используются для того, что в объектно-ориентированном стиле называют внедрением зависимостей . Например, алгоритм негамакса часто используется (в высокооптимизированных формах) для вычисления значения позиции в игре для двух игроков. Однако сам алгоритм не заботится о том, в какую игру вы играете, за исключением того, что вам нужно иметь возможность определять, какие «следующие» позиции находятся в игре, и вам нужно быть в состоянии определить, является ли текущая позиция победной.
import Control.Monad.Reader
data GameState = NotOver | FirstPlayerWin | SecondPlayerWin | Tie
data Game position
= Game {
getNext :: position -> [position],
getState :: position -> GameState
}
getNext' :: position -> Reader (Game position) [position]
getNext' position
= do game <- ask
return $ getNext game position
getState' :: position -> Reader (Game position) GameState
getState' position
= do game <- ask
return $ getState game position
negamax :: Double -> position -> Reader (Game position) Double
negamax color position
= do state <- getState' position
case state of
FirstPlayerWin -> return color
SecondPlayerWin -> return $ negate color
Tie -> return 0
NotOver -> do possible <- getNext' position
values <- mapM ((liftM negate) . negamax (negate color)) possible
return $ maximum values
Тогда это будет работать с любой конечной детерминированной игрой для двух игроков.
Этот шаблон полезен даже для вещей, которые на самом деле не являются внедрением зависимостей. Предположим, вы работаете в сфере финансов, вы можете разработать сложную логику для ценообразования актива (скажем, производного инструмента), что хорошо, и вы можете обойтись без каких-либо вонючих монад. Но затем вы изменяете свою программу, чтобы работать с несколькими валютами. Вам нужно иметь возможность конвертировать между валютами на лету. Ваша первая попытка - определить функцию верхнего уровня
type CurrencyDict = Map CurrencyName Dollars
currencyDict :: CurrencyDict
получить спотовые цены. Затем вы можете вызвать этот словарь в своем коде ... но подождите! Это не сработает! Валютный словарь неизменен и поэтому должен быть одинаковым не только на протяжении всей жизни вашей программы, но и с момента ее компиляции ! Ну так что ты делаешь? Ну, один из вариантов - использовать монаду Reader:
computePrice :: Reader CurrencyDict Dollars
computePrice
= do currencyDict <- ask
--insert computation here
Возможно, самый классический вариант использования - реализация интерпретаторов. Но прежде чем мы посмотрим на это, нам нужно ввести еще одну функцию
local :: (env -> env) -> Reader env a -> Reader env a
Итак, Haskell и другие функциональные языки основаны на лямбда-исчислении . Синтаксис лямбда-исчисления выглядит так:
data Term = Apply Term Term | Lambda String Term | Var Term deriving (Show)
и мы хотим написать оценщик для этого языка. Для этого нам нужно будет отслеживать среду, которая представляет собой список привязок, связанных с терминами (на самом деле это будут замыкания, потому что мы хотим сделать статическую область видимости).
newtype Env = Env ([(String, Closure)])
type Closure = (Term, Env)
Когда мы закончим, мы должны получить значение (или ошибку):
data Value = Lam String Closure | Failure String
Итак, напишем интерпретатор:
interp' :: Term -> Reader Env Value
--when we have a lambda term, we can just return it
interp' (Lambda nv t)
= do env <- ask
return $ Lam nv (t, env)
--when we run into a value, we look it up in the environment
interp' (Var v)
= do (Env env) <- ask
case lookup (show v) env of
-- if it is not in the environment we have a problem
Nothing -> return . Failure $ "unbound variable: " ++ (show v)
-- if it is in the environment, then we should interpret it
Just (term, env) -> local (const env) $ interp' term
--the complicated case is an application
interp' (Apply t1 t2)
= do v1 <- interp' t1
case v1 of
Failure s -> return (Failure s)
Lam nv clos -> local (\(Env ls) -> Env ((nv, clos) : ls)) $ interp' t2
--I guess not that complicated!
Наконец, мы можем использовать его, передав тривиальное окружение:
interp :: Term -> Value
interp term = runReader (interp' term) (Env [])
Вот и все. Полнофункциональный интерпретатор лямбда-исчисления.
Другой способ подумать об этом - спросить: как это реализовано? Ответ состоит в том, что монада чтения на самом деле одна из самых простых и элегантных из всех монад.
newtype Reader env a = Reader {runReader :: env -> a}
Reader - это просто причудливое название для функций! Мы уже определились, runReaderа как насчет других частей API? Ну, каждый Monad- это еще и Functor:
instance Functor (Reader env) where
fmap f (Reader g) = Reader $ f . g
Теперь, чтобы получить монаду:
instance Monad (Reader env) where
return x = Reader (\_ -> x)
(Reader f) >>= g = Reader $ \x -> runReader (g (f x)) x
что не так уж и страшно. askдействительно просто:
ask = Reader $ \x -> x
пока localне так уж и плохо:
local f (Reader g) = Reader $ \x -> runReader g (f x)
Итак, монада чтения - это просто функция. Зачем вообще нужен Reader? Хороший вопрос. Собственно, вам это и не нужно!
instance Functor ((->) env) where
fmap = (.)
instance Monad ((->) env) where
return = const
f >>= g = \x -> g (f x) x
Это еще проще. Более того, askэто просто idи localпросто композиция функций с порядком функций переключились!