Lambda recursive calls

Author: Bowen Fu

evaluator.cpp

@@ -1,18 +1,14 @@
 #include "evaluator.h"
 
-ExprPtr Lambda::eval(Env& env)
+ExprPtr Lambda::eval(std::shared_ptr<Env> const& env)
 {
-    CompoundProcedure proc{mBody, mParameters, std::make_shared<Env>(env)};
+    CompoundProcedure proc{mBody, mParameters, env};
     return std::shared_ptr<Expr>(new CompoundProcedure(proc));
 }
 
-ExprPtr Definition::eval(Env& env)
+ExprPtr Definition::eval(std::shared_ptr<Env> const& env)
 {
-    if (dynamic_cast<Lambda*>(mValue.get()))
-    {
-        return env.defineVariable(dynamic_cast<Variable*>(mVariable.get())->name(), mValue);
-    }
-    return env.defineVariable(dynamic_cast<Variable*>(mVariable.get())->name(), mValue->eval(env));
+    return env->defineVariable(dynamic_cast<Variable*>(mVariable.get())->name(), mValue->eval(env));
 }
 
 #if 0

evaluator.h

@@ -71,7 +71,7 @@ class Env
 class Expr
 {
 public:
-    virtual ExprPtr eval(Env& env) = 0;
+    virtual ExprPtr eval(std::shared_ptr<Env> const& env) = 0;
     virtual std::string toString() const = 0;
     virtual ~Expr() = default;
 };
@@ -84,7 +84,7 @@ class Literal : public Expr
     Literal(Value value)
     : mValue{value}
     {}
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
         return ExprPtr{new Literal(mValue)};
     }
@@ -107,9 +107,9 @@ class Variable final : public Expr
     Variable(std::string const& name)
     : mName{name}
     {}
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
-        return env.lookupVariableValue(mName);
+        return env->lookupVariableValue(mName);
     }
     std::string name() const
     {
@@ -125,7 +125,7 @@ class Quoted final : public Expr
 {
     ExprPtr mContent;
 public:
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
         return mContent;
     }
@@ -142,9 +142,9 @@ class Assignment final : public Expr
     , mValue{value}
     {
     }
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
-        return env.setVariableValue(dynamic_cast<Variable*>(mVariable.get())->name(), mValue->eval(env));
+        return env->setVariableValue(dynamic_cast<Variable*>(mVariable.get())->name(), mValue->eval(env));
     }
     std::string toString() const override
     {
@@ -162,7 +162,7 @@ class Definition final : public Expr
     , mValue{value}
     {
     }
-    ExprPtr eval(Env& env) override;
+    ExprPtr eval(std::shared_ptr<Env> const& env) override;
     std::string toString() const override
     {
         return "Definition  ( " + mVariable->toString() + " : " + mValue->toString() + " )";
@@ -187,7 +187,7 @@ class If final : public Expr
     , mConsequent{consequent}
     , mAlternative{alternative}
     {}
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
         return isTrue(mPredicate->eval(env)) ? mConsequent->eval(env) : mAlternative->eval(env);
     }
@@ -204,7 +204,7 @@ class Sequence final : public Expr
     Sequence(std::vector<ExprPtr> actions)
     : mActions{actions}
     {}
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
         assert(mActions.size() >= 1);
         for (size_t i = 0; i < mActions.size() - 1; i++)
@@ -229,7 +229,7 @@ class Lambda final : public Expr
     , mBody{body}
     {
     }
-    ExprPtr eval(Env& env) override;
+    ExprPtr eval(std::shared_ptr<Env> const& env) override;
     std::string toString() const override
     {
         return "Lambda";
@@ -240,11 +240,11 @@ class Cond final : public Expr
 {
     std::shared_ptr<Expr> mClauses;
 public:
-    ExprPtr eval(Env& env) override;
+    ExprPtr eval(std::shared_ptr<Env> const& env) override;
     std::string toString() const override;
 };
 
-inline std::vector<ExprPtr> listOfValues(std::vector<ExprPtr> const& exprs, Env& env)
+inline std::vector<ExprPtr> listOfValues(std::vector<ExprPtr> const& exprs, std::shared_ptr<Env> const& env)
 {
     std::vector<ExprPtr> values;
     std::transform(exprs.begin(), exprs.end(), std::back_insert_iterator(values), [&env](ExprPtr const& e)
@@ -269,7 +269,7 @@ class PrimitiveProcedure : public Procedure
     PrimitiveProcedure(Func func)
     : mImplementation{func}
     {}
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
         return ExprPtr{new PrimitiveProcedure{mImplementation}};
     }
@@ -289,18 +289,18 @@ class CompoundProcedure : public Procedure
     std::vector<std::string> mParameters;
     std::shared_ptr<Env> mEnvironment;
 public:
-    CompoundProcedure(std::shared_ptr<Sequence> body, std::vector<std::string> parameters, std::shared_ptr<Env> environment)
+    CompoundProcedure(std::shared_ptr<Sequence> body, std::vector<std::string> parameters, std::shared_ptr<Env> const& environment)
     : mBody{body}
     , mParameters{parameters}
     , mEnvironment{environment}
     {}
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
         return ExprPtr{new CompoundProcedure{mBody, mParameters, mEnvironment}};
     }
     std::shared_ptr<Expr> apply(std::vector<std::shared_ptr<Expr>> const& args) override
     {
-        return mBody->eval(*mEnvironment->extend(mParameters, args));
+        return mBody->eval(mEnvironment->extend(mParameters, args));
     }
     std::string toString() const override
     {
@@ -317,9 +317,9 @@ class Application final : public Expr
     : mOperator{op}
     , mOperands{params}
     {}
-    ExprPtr eval(Env& env) override
+    ExprPtr eval(std::shared_ptr<Env> const& env) override
     {
-        auto op = mOperator->eval(env)->eval(env);
+        auto op = mOperator->eval(env);
         auto args = listOfValues(mOperands, env);
         return dynamic_cast<Procedure&>(*op).apply(args);
     }

parser.cpp

@@ -275,7 +275,7 @@ int32_t main()
     }
     #endif
 
-    Env env{};
+    auto env = std::make_shared<Env>();
 
     using Number = Literal<double>;
     auto mul = [](std::vector<std::shared_ptr<Expr>> const& args)