programs/eq.lily

@@ -1,6 +0,0 @@
-defn main = {
-    case eq 1 1 of {
-        True -> { 326 }
-        False -> { 404 }
-    }
-}

programs/factorial.lily

@@ -1,12 +0,0 @@
-defn if c t e = {
-    case c of {
-        True -> { t }
-        False -> { e }
-    }
-}
-
-defn fact n = {
-    if (eq n 0) 1 (n * fact (n - 1))
-}
-
-defn main = { fact 6 }

programs/not.lily

@@ -1,3 +1,4 @@
+data Bool = { True, False }
 defn not b = {
     case b of {
         False -> { True }

src/gmachine.cpp

@@ -62,11 +62,6 @@ namespace lily {
         return os;
     }
 
-    std::ostream& instruction_eq::to_stream(std::ostream& os) {
-        os << "eq";
-        return os;
-    }
-
     std::ostream& instruction_cond::to_stream(std::ostream& os) {
         os << "cond";
         return os;
@@ -171,39 +166,6 @@ namespace lily {
         builder.CreateCall(stack_push_func, { stack, new_node });
     }
 
-    void instruction_eq::gen_llvm(llvm_context& ctx) {
-        llvm::Value* stack = ctx.get_current_function()->arg_begin();
-        llvm::Value* param2 = builder.CreateCall(stack_pop_func, { stack }, "temp");
-        llvm::Value* param1 = builder.CreateCall(stack_pop_func, { stack }, "temp");
-        llvm::Value* param1_node_num = builder.CreatePointerCast(param1, llvm::PointerType::getUnqual(node_num_type), "temp");
-        llvm::Value* param2_node_num = builder.CreatePointerCast(param2, llvm::PointerType::getUnqual(node_num_type), "temp");
-        llvm::Value* param1_intptr = builder.CreateGEP(param1_node_num, { get_int32_constant(0), get_int32_constant(1) }, "temp");
-        llvm::Value* param2_intptr = builder.CreateGEP(param2_node_num, { get_int32_constant(0), get_int32_constant(1) }, "temp");
-        llvm::Value* param1_int = builder.CreateLoad(llvm::IntegerType::get(context, 32), param1_intptr, "temp");
-        llvm::Value* param2_int = builder.CreateLoad(llvm::IntegerType::get(context, 32), param2_intptr, "temp");
-        llvm::Value* compare_result = builder.CreateICmpEQ(param1_int, param2_int, "temp");
-
-        llvm::BasicBlock* false_block = llvm::BasicBlock::Create(context, "false", ctx.get_current_function());
-        llvm::BasicBlock* true_block = llvm::BasicBlock::Create(context, "true", ctx.get_current_function());
-        builder.CreateCondBr(compare_result, true_block, false_block);
-
-        llvm::BasicBlock* after = llvm::BasicBlock::Create(context, "after", ctx.get_current_function());
-
-        builder.SetInsertPoint(false_block);
-        llvm::Value* false_node = builder.CreateCall(malloc_node_global_func,
-                { get_int8_constant(0), ctx.get_supercombinator_function("False") }, "temp");
-        builder.CreateCall(stack_push_func, { stack, false_node });
-        builder.CreateBr(after);
-
-        builder.SetInsertPoint(true_block);
-        llvm::Value* true_node = builder.CreateCall(malloc_node_global_func,
-                { get_int8_constant(0), ctx.get_supercombinator_function("True") }, "temp");
-        builder.CreateCall(stack_push_func, { stack, true_node });
-        builder.CreateBr(after);
-
-        builder.SetInsertPoint(after);
-    }
-
     void instruction_cond::gen_llvm(llvm_context& ctx) {
         
     }

src/gmachine.hpp

@@ -94,11 +94,6 @@ namespace lily {
         void gen_llvm(llvm_context& ctx);
     };
 
-    struct instruction_eq : instruction {
-        std::ostream& to_stream(std::ostream& os);
-        void gen_llvm(llvm_context& ctx);
-    };
-
     struct instruction_cond : instruction {
         std::vector<instruction*> true_branch;
         std::vector<instruction*> false_branch;

src/parser.cpp

@@ -246,13 +246,6 @@ namespace lily {
         return prog;
     }
 
-    program::program() {
-        type_data* data = type_mgr.create_data_type("Bool");
-        std::vector<type*> params;
-        data->create_constructor("True", std::move(params));
-        data->create_constructor("False", std::move(params));
-    }
-
     void program::check() {
         // Each function has an environment, which will be used
         // as base for type checking.
@@ -288,13 +281,6 @@ namespace lily {
             base_env->set_type(pair.first, current_type);
         }
 
-        // Also add internal functions
-        type* eq_return_type = type_mgr.require_type("Bool");
-        type* eq_param_type = type_mgr.require_type("Int");
-        type* eq_app_1 = type_mgr.create_type<type_func>(eq_param_type, eq_return_type);
-        type* eq_app_2 = type_mgr.create_type<type_func>(eq_param_type, eq_app_1);
-        base_env->set_type("eq", eq_app_2);
-
         // We also want to gather all the constructor calls.
         type_mgr.register_constructors(base_env);
 
@@ -325,16 +311,6 @@ namespace lily {
         generate_binop<binop::subtract>(mgr, into);
         generate_binop<binop::times>(mgr, into);
         generate_binop<binop::divide>(mgr, into);
-
-        std::vector<instruction*> dest;
-        dest.push_back(mgr.add_instruction<instruction_push>(1));
-        dest.push_back(mgr.add_instruction<instruction_eval>());
-        dest.push_back(mgr.add_instruction<instruction_push>(1));
-        dest.push_back(mgr.add_instruction<instruction_eval>());
-        dest.push_back(mgr.add_instruction<instruction_eq>());
-        dest.push_back(mgr.add_instruction<instruction_update>(2));
-        dest.push_back(mgr.add_instruction<instruction_pop>(2));
-        into["eq"] = std::move(dest);
     }
 
     void program::compile(instruction_manager& mgr, std::map<std::string, std::vector<instruction*>>& into) {

src/parser.hpp

@@ -13,8 +13,6 @@ namespace lily {
         type_manager type_mgr;
         std::map<std::string, function> functions;
 
-        program();
-
         void check();
         void compile(instruction_manager& mgr, std::map<std::string, std::vector<instruction*>>& into);
         void gen_llvm();