[haskell] 리더 모나드의 목적은 무엇입니까?

겁 먹지마! 리더 모나드는 실제로 그렇게 복잡하지 않고 사용하기 쉬운 유틸리티를 가지고 있습니다.

모나드에 접근하는 방법에는 두 가지가 있습니다.

1. 모나드 는 무엇을합니까? 어떤 작업을 갖추고 있습니까? 무엇에 좋은가요?
2. 모나드는 어떻게 구현됩니까? 어디에서 발생합니까?

첫 번째 접근 방식에서 독자 모나드는 추상적 인 유형입니다.

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

그렇다면 이것을 어떻게 사용합니까? 글쎄, 리더 모나드는 계산을 통해 (암시 적) 구성 정보를 전달하는 데 좋습니다.

다양한 지점에서 필요한 계산에 “상수”가 있지만 실제로는 다른 값으로 동일한 계산을 수행 할 수 있기를 원할 때마다 리더 모나드를 사용해야합니다.

리더 모나드는 OO 사람들이 의존성 주입 이라고 부르는 작업을 수행하는데도 사용됩니다 . 예를 들어, negamax 알고리즘은 2 인 게임에서 위치 값을 계산하기 위해 자주 (고도로 최적화 된 형태로) 사용됩니다. 그러나 알고리즘 자체는 게임에서 “다음”위치가 무엇인지 결정할 수 있어야하고 현재 위치가 승리 위치인지 알 수 있어야한다는 점을 제외하고는 어떤 게임을하고 있는지 상관하지 않습니다.

 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

그러면 유한하고 결정적인 2 인용 게임에서 작동합니다.

이 패턴은 실제로 의존성 주입이 아닌 것들에도 유용합니다. 금융 분야에서 일한다고 가정 해보면 자산 가격 책정을위한 복잡한 논리를 설계 할 수 있습니다 (파생물 말).이 모든 것은 훌륭하고 악취 나는 모나드 없이도 할 수 있습니다. 그러나 여러 통화를 처리하도록 프로그램을 수정합니다. 즉석에서 통화 간 변환이 가능해야합니다. 첫 번째 시도는 최상위 기능을 정의하는 것입니다.

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

좋습니다. 하스켈과 다른 기능적 언어는 람다 미적분을 기반으로합니다 . Lambda 미적분에는 다음과 같은 구문이 있습니다.

 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전환 기능의 순서로 단지 함수의 합성입니다!

답변

import Control.Applicative

-- | A History with timeline type t and value type a.
newtype History t a = History { observe :: t -> a }

instance Functor (History t) where
    -- Apply a function to the contents of a historical value
    fmap f hist = History (f . observe hist)

instance Applicative (History t) where
    -- A "pure" History is one that has the same value at all points in time
    pure = History . const

    -- This applies a function that changes over time to a value that also 
    -- changes, by observing both at the same point in time.
    ff <*> fx = History $ \t -> (observe ff t) (observe fx t)

instance Monad (History t) where
    return = pure
    ma >>= f = History $ \t -> observe (f (observe ma t)) t

-- | For any given day, the list of employees followed by the customers
employeesAndCustomers :: History Day [Person]
employeesAndCustomers = (++) <$> employees <*> customers

newtype Hypercube intersection value = Hypercube { get :: intersection -> value }

instance Functor (Hypercube intersection) where
    fmap f cube = Hypercube (f . get cube)


instance Applicative (Hypercube intersection) where
    -- A "pure" Hypercube is one that has the same value at all intersections
    pure = Hypercube . const

    -- Apply each function in the @ff@ hypercube to its corresponding point 
    -- in @fx@.
    ff <*> fx = Hypercube $ \x -> (get ff x) (get fx x)