How do you evaluate a lambda expression in Haskell? - parsing

Question

Lambdas have the form: (lambda (var) expr) and represent an anonymous function that takes a single argument. There are no multi-argument functions in MiniRacket.
data Expr
= LambdaExpr String Expr
| LetExpr String Expr Expr
deriving (Show, Eq)
Evaluating a lambda should result in a closure, which is the function body, the name of the argument to it, and the current environment when the function was defined. This environment is then used when applying the function because it should let us know which bindings were available up until that point.
Here is my evalLambdaExpr
-- evaluate lambdas, which requires storing the current environment as the closure,
-- this should result in a ClosureVal, which can later be used for apply, if it's
-- a totally anonymous function, then "" is the function name, otherwise if it was
-- built with a let expression, then the let name is its name.
evalLambdaExpr :: Evaluator Value
evalLambdaExpr = do
(env, LambdaExpr letName valexpr) <- next
case getValue (eval evalExpr (env, valexpr)) of
Right (ClosureVal "" argName funBody cenv) ->
let env = Env.bind "" (ClosureVal "" argName funBody cenv) cenv
in case getValue (eval evalExpr (env, funBody)) of
Right v -> return v
Left err -> evalError err
Right nameval ->
case getValue (eval evalExpr (bind letName nameval env, valexpr)) of
Right letval -> return letval
Left err -> evalError err
Left err -> evalError err
-- and an Alternative ...
instance Alternative Evaluator where
empty = failEval "no matching evaluation"
-- define the type for values, which in our mini language
-- can be integers, bools, pairs, or closures
data Value
= IntVal Integer
| BoolVal Bool
| PairVal (Value, Value)
| ClosureVal String String Expr ValueEnv
deriving (Show, Eq)
newtype Evaluator a = E {eval :: (ValueEnv, Expr) -> Either ErrorT (a, (ValueEnv, Expr))}
-- this is the basic evaluator, it ends when ast is an EmptyExpr, but otherwise,
-- we get the the environment and expr returned
next :: Evaluator (ValueEnv, Expr)
next =
E
( \parserState -> case parserState of
(_, EmptyExpr) -> Left $ EvalError "no more expressions"
(env, x) -> Right ((env, x), (env, EmptyExpr))
)
evalError :: ErrorT -> Evaluator a
evalError err = E (\_ -> Left err)
My evalLambdaExpr is always returning a Left; why is that?
As an example, my evalLetExpr is working correctly and this is what I have:
-- Evaluate a let expression. This first evaluates the
-- argument to the identifier. Once that is evaluated, I
-- bind the value to the name in a new environment, then
-- I evaluate the body with this new environment
evalLetExpr :: Evaluator Value
evalLetExpr = do
(env, LetExpr letName valexpr body) <- next
case getValue (eval evalExpr (env, valexpr)) of
-- we got a closure from it, but it doesn't have a name,
-- so let's add that to the closure as its 'funname'
Right (ClosureVal "" argName funBody cenv) ->
let env' = Env.bind letName (ClosureVal letName argName funBody cenv) cenv
in case getValue (eval evalExpr (env', body)) of
Right v -> return v
Left err -> evalError err
Right nameval ->
case getValue (eval evalExpr (bind letName nameval env, body)) of
Right letval -> return letval
Left err -> evalError err
Left err -> evalError err
For both evaluators, I commented what they do on above them. Why is evalStr "(lambda (x) true)" returning Left (EvalError "no matching evaluation")?
I know it's not my parsing because that works.

Answer 1

evalLambdaExpr :: Evaluator Value
evalLambdaExpr = do
(env, LambdaExpr letName valexpr) <- next
case getValue (eval evalExpr (env, valexpr)) of
Hmm. As far as I understand, this says that in order to evaluate (lambda (x) (+ x 1)), we should evaluate (+ x 1) immediately. That is not what should happen -- the body of the lambda should only be evaluated when the closure is applied -- after all, we don't even know what the value of x should be in that expression.
I am not sure if this is what is causing your error, but I would expect this to cause all sorts of weird things to happen as you try to evaluate expressions at the wrong time with unbound variables.
One typically needs an Expr constructor for applying a lambda to an argument.