Reader Monad

-- | Reader is een wrapper rondom een functie, zodat we een groot aantal
-- functies die op hetzelfde argument (de omgeving) toegepast worden, kunnen
-- combineren.
newtype Reader env a = Reader { runReader :: env -> a }

-- | Een Reader is een Monad.
instance Monad (Reader env) where
    return = undefined
    (>>=) = undefined

instance Applicative (Reader env) where
    pure = undefined
    (<*>) = undefined

instance Functor (Reader env) where
    fmap = undefined

-- | Vraag de omgeving op - gelijkaardig aan "get" van State.
ask :: Reader env env
ask = undefined

-- | Voer een gegeven Reader uit binnen een lokaal gewijzigde omgeving.
local :: (env -> env') -> (Reader env' a -> Reader env a)
local = undefined

type Name = String

data Term = Add Term Term
          | App Term Term
          | Lam Name Term
          | Var Name
          | Con Int
          deriving (Eq, Show)

-- Een omgeving werkt hier iets anders dan in de 'Monadische Interpreters'
-- oefeningenreeks. Een variabelenaam wordt gemapt op een closure. Een closure
-- is een (nog te berekenen) term, tesamen met de context (zelf een omgeving)
-- waarin die berekend moet worden.

type Env = [(String, Closure)]
data Closure = Closure Term Env deriving (Eq, Show)

-- Dit geeft ook een iets andere functie-waarde definitie. Een functie bestaat
-- uit een variabelenaam en een closure: dus een variabelenaam (die we moeten
-- "toekennen"), een term (de "body" die we moeten evalueren) en de context van
-- het moment van aanmaken.

data Value = Wrong
           | Num Int
           | Fun Name Closure
           deriving (Eq, Show)

interp :: Term -> Reader Env Value
interp (Con x) = return $ Num x
interp (Add e1 e2) = do v1 <- interp e1
                        v2 <- interp e2
                        add v1 v2
interp (Lam v e) = do env <- ask
                      return $ Fun v (Closure e env)
interp (Var v) = do env <- ask
                    interpClosure (lookup v env)
interp (App e1 e2) = do v1 <- interp e1
                        app v1 e2

-- | Tel twee waarden op - als het getallen zijn.
add :: Value -> Value -> Reader Env Value
add = undefined

-- | Bereken de waarde van een closure - als de closure bestaat.
interpClosure :: Maybe Closure -> Reader Env Value
interpClosure = undefined

-- | Pas een waarde toe op een term - als het een lambda is.
app :: Value -> Term -> Reader Env Value
app = undefined

runInterpreter :: Term -> Value
runInterpreter e = runReader (interp e) ([])