Conditionals work properly now. Yay!

Author: Iainmon

README.md

@@ -1,9 +1,14 @@
 # LambdaScript
+
+Dear reader,
+
+I challenged myself to make a programming language during the summer before I started college. This project implemented the semantic rules of the lambda calculus, but with a few extra features. I have written a javascript code compiler for it, and an interpreter. The interpreter works well, but does not throw proper errors (haven't implemented exceptions), unable to evaluate conditionals that exist inside of abstractions, and resolve types properly. It is fully functional if you wish to only use pure lambda encodings, rather than the native arithmetical evaluation engine. 
+
 Examples:
 ```haskell
 -- interactive mode
-id = (λx.x)
-λ -> [ λ function ] (λx.x)
+id = (λx.x) (λx.x)
+λ -> (λx.x)
 
 id 103
 λ -> 103

source/ast/ast.cpp

@@ -233,6 +233,24 @@ node_reference Operation::accept(backend::NodeVisitor *visitor) {
     return visitor->visitArithmeticalOperation(self);
 }
 
+Condition::Condition(node_reference _condition, node_reference _consequent, node_reference _alternative) {
+    condition = _condition;
+    consequent = _consequent;
+    alternative = _alternative;
+}
+
+std::string Condition::to_string() {
+    return "if " + condition->to_string() + " then " + consequent->to_string() + " else " + alternative->to_string();
+}
+std::string Condition::pretty_print() {
+    return "(" + condition->pretty_print() + blue + " -> " + reset + consequent->pretty_print() + blue + " | " + reset + alternative->pretty_print() + ")";
+    return blue + "if " + reset + condition->pretty_print() + blue + " then " + reset + consequent->pretty_print() + blue + " else " + reset + alternative->pretty_print();
+}
+node_reference Condition::accept(backend::NodeVisitor *visitor) {
+    shared_ptr<Condition> self = static_pointer_cast<Condition>(shared_from_this());
+    return visitor->visitCondition(self);
+}
+
 PrintInstruction::PrintInstruction(node_reference valueToPrint) {
     type = PRINT;
     value = valueToPrint;

source/ast/ast.h

@@ -24,7 +24,7 @@ class ImportInstruction;
 class Operation;
 class Assignment;
 class NativeAbstraction;
-// class Conditional;
+class Condition;
 
 namespace typesystem {
     class TypeNode;
@@ -172,6 +172,17 @@ class Operation : public ASTNode {
     node_reference accept(backend::NodeVisitor *visitor) override;
 };
 
+class Condition : public ASTNode {
+    public:
+    node_reference condition;
+    node_reference consequent;
+    node_reference alternative;
+    Condition(node_reference _condition, node_reference _consequent, node_reference _alternative);
+    std::string to_string() override;
+    std::string pretty_print() override;
+    node_reference accept(backend::NodeVisitor *visitor) override;
+};
+
 class PrintInstruction : public ASTNode {
     public:
     node_reference value;

source/backend/NodeVisitor.cpp

@@ -27,6 +27,10 @@ ast::node_reference backend::NodeVisitor::visitArithmeticalOperation(std::shared
     op_node->operation_character = operation->operation_character;
     return op;
 }
+ast::node_reference backend::NodeVisitor::visitCondition(std::shared_ptr<ast::Condition> condition) {
+    std::shared_ptr<ast::Condition> con = std::make_shared<ast::Condition>(condition->condition->accept(this), condition->consequent->accept(this), condition->alternative->accept(this));
+    return con;
+}
 ast::node_reference backend::NodeVisitor::visitNativeAbstraction(std::shared_ptr<ast::NativeAbstraction> native_abstraction) {
     // Will call the native_abstractions .apply() method, where it will construct an AST tree
     // Sometimes the use of a new Curryable object will be used to keep track of previously provided arguments, until all are met, and the expression can be executed internally.

source/backend/NodeVisitor.h

@@ -15,6 +15,7 @@ namespace backend {
         virtual ast::node_reference visitAbstraction(std::shared_ptr<ast::Abstraction>);
         virtual ast::node_reference visitAssignment(std::shared_ptr<ast::Assignment>);
         virtual ast::node_reference visitArithmeticalOperation(std::shared_ptr<ast::Operation>);
+        virtual ast::node_reference visitCondition(std::shared_ptr<ast::Condition>);
         virtual ast::node_reference visitGrouping(std::shared_ptr<ast::Grouping>);
         virtual ast::node_reference visitNativeAbstraction(std::shared_ptr<ast::NativeAbstraction>);
         virtual ast::node_reference visitImportInstruction(std::shared_ptr<ast::ImportInstruction>);

source/backend/interpreter/Curried.cpp

@@ -30,8 +30,8 @@ ast::node_reference backend::interpreter::Curried::accept(backend::NodeVisitor*
             return interpreter_visitor->visitCurried(self);
         } else {
             // return visitor->visitGenericASTNode(generic_self);
-            // return generic_self;
-            return target_native_abstraction->accept(visitor);
+            return std::static_pointer_cast<backend::interpreter::Curried>(generic_self);
+            // return target_native_abstraction->accept(visitor);
         }
     }
 }

source/backend/interpreter/InterpreterVisitor.cpp

@@ -38,11 +38,15 @@ ast::node_reference backend::interpreter::InterpreterVisitor::visitApplication(s
     // std::cout << "[app] " << application->pretty_print() << std::endl;
     ast::node_reference reduced_lhs = application->lhs->accept(this);
     // std::cout << "Is this code even being called? " << typeid(*reduced_lhs).name() << std::endl;
-    if (!(typeid(*reduced_lhs) == typeid(ast::Abstraction))) {
-        if (typeid(*reduced_lhs) == typeid(backend::interpreter::Curried)) {
-            std::shared_ptr<backend::interpreter::Curried> curried = std::static_pointer_cast<backend::interpreter::Curried>(reduced_lhs);
-            return curried->apply_argument(application->rhs->accept(this))->accept(this)->accept(this);
+    if (typeid(*reduced_lhs) == typeid(backend::interpreter::Curried)) {
+        std::shared_ptr<backend::interpreter::Curried> curried = std::static_pointer_cast<backend::interpreter::Curried>(reduced_lhs);
+        ast::node_reference reduced_rhs = application->rhs->accept(this);
+        if (typeid(*reduced_rhs) == typeid(ast::Variable)) {
+            return application;
         }
+        return curried->apply_argument(reduced_rhs)->accept(this);
+    }
+    if (!(typeid(*reduced_lhs) == typeid(ast::Abstraction))) {
         if (typeid(*reduced_lhs) == typeid(ast::Literal) || typeid(*reduced_lhs) == typeid(ast::Grouping)) {
             std::shared_ptr<ast::Grouping> grouping = std::make_shared<ast::Grouping>();
             grouping->nodes.push_back(reduced_lhs);
@@ -81,6 +85,25 @@ ast::node_reference backend::interpreter::InterpreterVisitor::visitArithmeticalO
     ast::node_reference operation_result = backend::evaluate_arithmetical_operation(op);
     return operation_result;
 }
+ast::node_reference backend::interpreter::InterpreterVisitor::visitCondition(std::shared_ptr<ast::Condition> condition) {
+    ast::node_reference con = condition->condition->accept(this);
+    bool truthy;
+    if (typeid(*con) == typeid(ast::Literal)) {
+        std::shared_ptr<ast::Literal> literal = std::static_pointer_cast<ast::Literal>(con);
+        if (literal->valueType == ast::LiteralType::Int) {
+            truthy = literal->getInt() > 0;
+        } else if (literal->valueType == ast::LiteralType::Bool) {
+            truthy = literal->getBool();
+        } else if (literal->valueType == ast::LiteralType::Nil) {
+            truthy = false;
+        } else {
+            truthy = false;
+        }
+    } else {
+        truthy = false;
+    }
+    return truthy ? condition->consequent->accept(this) : condition->alternative->accept(this);
+}
 ast::node_reference backend::interpreter::InterpreterVisitor::visitNativeAbstraction(std::shared_ptr<ast::NativeAbstraction> native_abstraction) {
     // Will call the native_abstractions .apply() method, where it will construct an AST tree
     // Sometimes the use of a new Curryable object will be used to keep track of previously provided arguments, until all are met, and the expression can be executed internally.

source/backend/interpreter/InterpreterVisitor.h

@@ -30,6 +30,7 @@ class InterpreterVisitor : public NodeVisitor {
     ast::node_reference visitArithmeticalOperation(std::shared_ptr<ast::Operation>) override;
     ast::node_reference visitGrouping(std::shared_ptr<ast::Grouping>) override;
     ast::node_reference visitNativeAbstraction(std::shared_ptr<ast::NativeAbstraction>) override;
+    ast::node_reference visitCondition(std::shared_ptr<ast::Condition>) override;
     ast::node_reference visitImportInstruction(std::shared_ptr<ast::ImportInstruction>) override;
     ast::node_reference visitPrintInstruction(std::shared_ptr<ast::PrintInstruction>) override;
     ast::node_reference visitGenericASTNode(std::shared_ptr<ast::ASTNode>) override;

source/language/ConstructorVisitor.cpp

@@ -156,18 +156,12 @@ antlrcpp::Any ConstructorVisitor::visitBody(LanguageParser::BodyContext *ctx) {
 antlrcpp::Any ConstructorVisitor::visitCondition(LanguageParser::ConditionContext *ctx) {
 
     ast::node_reference condition = ctx->expression()->accept(this);
-    ast::node_reference tru_expression = ctx->body(0)->accept(this);
-    ast::node_reference fls_expression = ctx->body(1)->accept(this);
+    ast::node_reference consequent = ctx->body(0)->accept(this);
+    ast::node_reference alternitive = ctx->body(1)->accept(this);
 
-    // [flag TODO]
-    // This is not the way to go. Conditionals should exist as an AST node, instead of being encoded as truthy applications.
-
-    ast::node_reference native_truthy = std::make_shared<backend::interpreter::Curried>(std::make_shared<backend::interpreter::native_library::Truthy>(), 1);
+    ast::node_reference condition_node = std::make_shared<ast::Condition>(condition, consequent, alternitive);
 
-    ast::node_reference application_0 = make_shared<ast::Application>(native_truthy, condition);
-    ast::node_reference application_1 = make_shared<ast::Application>(application_0, tru_expression);
-    ast::node_reference application_2 = make_shared<ast::Application>(application_1, fls_expression);
-    return application_2;
+    return condition_node;
 }
 
 antlrcpp::Any ConstructorVisitor::visitTypeBinding(LanguageParser::TypeBindingContext *ctx) {