Lambda recursive calls

Author: Bowen Fu

evaluator.cpp

@@ -6,6 +6,15 @@ ExprPtr Lambda::eval(Env& env)
     return std::shared_ptr<Expr>(new CompoundProcedure(proc));
 }
 
+ExprPtr Definition::eval(Env& 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));
+}
+
 #if 0
 int32_t main()
 {

evaluator.h

@@ -162,10 +162,7 @@ class Definition final : public Expr
     , mValue{value}
     {
     }
-    ExprPtr eval(Env& env) override
-    {
-        return env.defineVariable(dynamic_cast<Variable*>(mVariable.get())->name(), mValue->eval(env));
-    }
+    ExprPtr eval(Env& env) override;
     std::string toString() const override
     {
         return "Definition  ( " + mVariable->toString() + " : " + mValue->toString() + " )";
@@ -185,11 +182,19 @@ class If final : public Expr
     ExprPtr mConsequent;
     ExprPtr mAlternative;
 public:
+    If(ExprPtr const& predicate, ExprPtr const& consequent, ExprPtr const& alternative)
+    : mPredicate{predicate}
+    , mConsequent{consequent}
+    , mAlternative{alternative}
+    {}
     ExprPtr eval(Env& env) override
     {
         return isTrue(mPredicate->eval(env)) ? mConsequent->eval(env) : mAlternative->eval(env);
     }
-    std::string toString() const override;
+    std::string toString() const override
+    {
+        return "(if " + mPredicate->toString() + " " + mConsequent->toString() + " " + mAlternative->toString() + ")";
+    }
 };
 
 class Sequence final : public Expr
@@ -314,7 +319,7 @@ class Application final : public Expr
     {}
     ExprPtr eval(Env& env) override
     {
-        auto op = mOperator->eval(env);
+        auto op = mOperator->eval(env)->eval(env);
         auto args = listOfValues(mOperands, env);
         return dynamic_cast<Procedure&>(*op).apply(args);
     }

parser.cpp

@@ -146,7 +146,8 @@ class Parser
     ExprPtr atomic()
     {
         assert(mLookAhead.type == TokenType::kWORD);
-        if (isdigit(mLookAhead.text.front()))
+        auto c = mLookAhead.text.front();
+        if (isdigit(c) || (mLookAhead.text.size() > 1 && c == '-'))
         {
             return number();
         }
@@ -184,6 +185,10 @@ class Parser
             {
                 return lambda();
             }
+            else if (mLookAhead.text == "if")
+            {
+                return if_();
+            }
             else
             {
                 return application();
@@ -231,6 +236,14 @@ class Parser
         auto body = sequence();
         return ExprPtr{new Lambda(params, body)};
     }
+    ExprPtr if_()
+    {
+        assert(match({TokenType::kWORD, "if"}));
+        auto predicate = sexpr();
+        auto consequent = sexpr();
+        auto alternative = sexpr();
+        return ExprPtr{new If(predicate, consequent, alternative)};
+    }
     ExprPtr application()
     {
         auto op = sexpr();
@@ -249,15 +262,18 @@ class Parser
 
 int32_t main()
 {
-    Lexer lex("(define square (lambda (y) (* y y))) (square 7)");
+    // Lexer lex("(define square (lambda (y) (* y y))) (square 7)");
+    Lexer lex("(define factorial (lambda (y) (if (= y 0) 1 (* y (factorial (- y 1)))))) (factorial 5)");
     Parser p(lex);
 
+    #if 0
     auto t = lex.nextToken();
     while (t.type != TokenType::kEOF)
     {
         std::cout << t.text << std::endl;
         t = lex.nextToken();
     }
+    #endif
 
     Env env{};
 
@@ -272,11 +288,41 @@ int32_t main()
         );
         return std::shared_ptr<Expr>(new Number(result)); 
     };
-    auto mulOp = ExprPtr{new PrimitiveProcedure{mul}};
-    auto variableMul = ExprPtr{new Variable{"*"}};
-    auto defMul = Definition(variableMul, mulOp);
+    auto defMul = Definition(ExprPtr{new Variable{"*"}}, ExprPtr{new PrimitiveProcedure{mul}});
     defMul.eval(env);
 
+    auto gt = [](std::vector<std::shared_ptr<Expr>> const& args)
+    {
+        assert(args.size() == 2);
+        auto num1 = dynamic_cast<Number&>(*args.at(0));
+        auto num2 = dynamic_cast<Number&>(*args.at(1));
+        using Bool = Literal<bool>;
+        return std::shared_ptr<Expr>(new Bool(num1.get() > num2.get())); 
+    };
+    auto defGT = Definition(ExprPtr{new Variable{">"}}, ExprPtr{new PrimitiveProcedure{gt}});
+    defGT.eval(env);
+
+    auto eq = [](std::vector<std::shared_ptr<Expr>> const& args)
+    {
+        assert(args.size() == 2);
+        auto num1 = dynamic_cast<Number&>(*args.at(0));
+        auto num2 = dynamic_cast<Number&>(*args.at(1));
+        using Bool = Literal<bool>;
+        return std::shared_ptr<Expr>(new Bool(num1.get() == num2.get())); 
+    };
+    auto defEQ = Definition(ExprPtr{new Variable{"="}}, ExprPtr{new PrimitiveProcedure{eq}});
+    defEQ.eval(env);
+
+    auto sub = [](std::vector<std::shared_ptr<Expr>> const& args)
+    {
+        assert(args.size() == 2);
+        auto num1 = dynamic_cast<Number&>(*args.at(0));
+        auto num2 = dynamic_cast<Number&>(*args.at(1));
+        return std::shared_ptr<Expr>(new Number(num1.get() - num2.get())); 
+    };
+    auto defSub = Definition(ExprPtr{new Variable{"-"}}, ExprPtr{new PrimitiveProcedure{sub}});
+    defSub.eval(env);
+
     auto e = p.sexpr();
     while (true)
     {