Lexical scoping is working, but `defun` broke because of that.

Need macros next

bin/pre.slime

@@ -1,196 +1,197 @@
 (define defmacro
   (macro (@name @params :rest @body)
      "Macro for creating macros with a more concise syntax."
-     (eval (pair 'define (pair @name (pair (pair 'macro (pair @params @body)) nil))))))
+     (eval (pair 'define-upwards (pair @name (pair (pair 'macro (pair @params @body)) nil))))))
 
-(defmacro defun (@name @params :rest @body)
+(define defun
+  (macro (@name @params :rest @body)
     "Macro for creating functions with a more concise syntax."
-    (eval (pair 'define (pair @name (pair (pair 'lambda (pair @params @body)) nil)))))
-
-(defun nil? (x)
-  "Checks if the argument is nil."
-  (= x nil))
-
-(defun number? (x)
-  "Checks if the argument is a number."
-  (= (type x) :number))
-
-(defun symbol? (x)
-  "Checks if the argument is a symbol."
-  (= (type x) :symbol))
-
-(defun keyword? (x)
-  "Checks if the argument is a keyword."
-  (= (type x) :keyword))
-
-(defun pair? (x)
-  "Checks if the argument is a pair."
-  (= (type x) :pair))
-
-(defun string? (x)
-  "Checks if the argument is a string."
-  (= (type x) :string))
-
-(defun dynamic-function? (x)
-  "Checks if the argument is a function."
-  (= (type x) :dynamic-function))
-
-(defun dynamic-macro? (x)
-  "Checks if the argument is a macro."
-  (= (type x) :dynamic-macro))
-
-(defun built-in-function? (x)
-  "Checks if the argument is a built-in function."
-  (= (type x) :built-in-function))
-
-(defun apply (fun seq)
-  "Applies the funciton to the sequence, as in calls the funciton with
-ithe sequence as arguemens."
-  (eval (pair fun seq)))
-
-(defmacro when (@test :rest @body)
-  "Executes the code in :rest if test is true."
-  (if (eval @test)
-      (eval (pair prog @body))
-    nil))
-
-(defmacro unless (@test :rest @body)
-  "Executes the code in :rest if test is false."
-  (if (eval @test)
-      nil
-    (eval (pair prog @body))))
-
-(defun end (seq)
-  "Returns the last pair in the sqeuence."
-  (if (or (nil? seq) (not (pair? (rest seq))))
-      seq
-    (end (rest seq))))
-
-(defun last (seq)
-  "Returns the (first) of the last (pair) of the given sequence."
-  (first (end seq)))
-
-(defun extend (seq elem)
-  "Extends a list with the given element, by putting it in
-the (rest) of the last element of the sequence."
-  (when (pair? seq)
-    (define e (end seq))
-    (mutate e (pair (first e) elem)))
-  seq)
-
-(defun incr (val)
-  "Adds one to the argument."
-  (+ val 1))
-
-(defun decr (val)
-  "Subtracts one from the argument."
-  (- val 1))
-
-(defun append (seq elem)
-  "Appends an element to a sequence, by extendeing the list
-with (pair elem nil)."
-  (extend seq (pair elem nil)))
-
-(defun length (seq)
-  "Returns the length of the given sequence."
-  (if (nil? seq)
-      0
-    (incr (length (rest seq)))))
-
-(defmacro n-times (@times @action)
-  "Executes @action @times times."
-  (unless (<= (eval @times) 0)
-    (eval @action)
-    (apply n-times (list (list - @times 1) @action))))
-
-(defmacro for (@symbol @from @to :rest @for-body)
-  "Designed to resemble a C style for loop. It takes a symbol as
-well as its starting number and end number and executes the
-@for-body with the defined symbol for all numbers between @from
-to @to, where @to is exclusive."
-  (if (< (eval @from) (eval @to))
-      (macro-define @op incr)
-    (if (> (eval @from) (eval @to))
-        (macro-define @op decr)
-      (macro-define @op nil)))
-  (when @op
-     (macro-define (eval @symbol) (eval @from))
-     (eval (pair prog @for-body))
-     (eval (extend (list for @symbol (@op @from) @to) @for-body))))
-
-(defun range (:keys from :defaults-to 0 to)
-  "Returns a sequence of numbers starting with the number defined
-by the key 'from' and ends with the number defined in 'to'."
-  (when (< from to)
-      (pair from (range :from (+ 1 from) :to to))))
-
-(defun range-while (:keys from :defaults-to 0 to)
-  "Returns a sequence of numbers starting with the number defined
-by the key 'from' and ends with the number defined in 'to'."
-  (define result (list (copy from)))
-  (define head result)
-  (mutate from (incr from))
-  (while (< from to)
-    (prog
-     (mutate head (pair (first head) (pair (copy from) nil)))
-     (define head (rest head))
-     (mutate from (incr from))))
-  result)
-
-(defun map (fun seq)
-  "Takes a function and a sequence as arguments and returns a new
-sequence which contains the results of using the first sequences
-elemens as argument to that function."
-  (if (nil? seq)
-      seq
-    (pair (fun (first seq))
-          (map fun (rest seq)))))
-
-(defun reduce (fun seq)
-  "Takes a function and a sequence as arguments and applies the
-function to the argument sequence. This only works correctly if
-the given function accepts a variable amount of parameters. If
-your funciton is limited to two arguments, use `reduce-binary'
-instead."
-  (apply fun seq))
-
-(defun reduce-binary (fun seq)
-  "Takes a function and a sequence as arguments and applies the
-function to the argument sequence. reduce-binary applies the
-arguments `pair-wise' which means it works with binary functions
-as compared to `reduce'."
-  (if (nil? (rest seq))
-      (first seq)
-    (fun (first seq)
-         (reduce-binary fun (rest seq)))))
-
-(defun filter (fun seq)
-  "Takes a function and a sequence as arguments and applies the
-function to every value in the sequence. If the result of that
-funciton application returns a truthy value, the original value is
-added to a list, which in the end is returned."
-  (when seq
-    (if (fun (first seq))
-        (pair (first seq)
-              (filter fun (rest seq)))
-      (filter fun (rest seq)))))
-
-(defun printf (:keys sep :defaults-to " " end :defaults-to "\n" :rest args)
-  "A wrapper for the built-in (print) that accepts a variable number
-of arguments and also provides keywords for specifying the printed
-separators between the arguments and what should be printed after the
-las argument."
-  (defmacro printf-quoted (:keys @sep @end :rest @args)
-    (if (nil? @args)
-        (prog (print (eval @end)) nil)
-      (prog
-       (print (first @args))
-       (unless (nil? (rest @args))
-         (print (eval @sep)))
-       (eval (pair printf-quoted
-              (extend (list :@sep (eval @sep) :@end (eval @end)) (rest @args)))))))
-
-  (eval (pair printf-quoted (extend (list :@sep (eval sep) :@end (eval end)) args))))
-
-(defmacro pe (@expr)
-  (printf @expr "evaluates to" (eval @expr)))
+    (eval (pair 'define-upwards (pair @name (pair (pair 'lambda (pair @params @body)) nil))))))
+
+;; (defun nil? (x)
+;;   "Checks if the argument is nil."
+;;   (= x nil))
+
+;; (defun number? (x)
+;;   "Checks if the argument is a number."
+;;   (= (type x) :number))
+
+;; (defun symbol? (x)
+;;   "Checks if the argument is a symbol."
+;;   (= (type x) :symbol))
+
+;; (defun keyword? (x)
+;;   "Checks if the argument is a keyword."
+;;   (= (type x) :keyword))
+
+;; (defun pair? (x)
+;;   "Checks if the argument is a pair."
+;;   (= (type x) :pair))
+
+;; (defun string? (x)
+;;   "Checks if the argument is a string."
+;;   (= (type x) :string))
+
+;; (defun dynamic-function? (x)
+;;   "Checks if the argument is a function."
+;;   (= (type x) :dynamic-function))
+
+;; (defun dynamic-macro? (x)
+;;   "Checks if the argument is a macro."
+;;   (= (type x) :dynamic-macro))
+
+;; (defun built-in-function? (x)
+;;   "Checks if the argument is a built-in function."
+;;   (= (type x) :built-in-function))
+
+;; (defun apply (fun seq)
+;;   "Applies the funciton to the sequence, as in calls the function
+;; with ithe sequence as arguemens."
+;;   (eval (pair fun seq)))
+
+;; (defmacro when (@test :rest @body)
+;;   "Executes the code in :rest if test is true."
+;;   (if (eval @test)
+;;       (eval (pair prog @body))
+;;     nil))
+
+;; (defmacro unless (@test :rest @body)
+;;   "Executes the code in :rest if test is false."
+;;   (if (eval @test)
+;;       nil
+;;     (eval (pair prog @body))))
+
+;; (defun end (seq)
+;;   "Returns the last pair in the sqeuence."
+;;   (if (or (nil? seq) (not (pair? (rest seq))))
+;;       seq
+;;     (end (rest seq))))
+
+;; (defun last (seq)
+;;   "Returns the (first) of the last (pair) of the given sequence."
+;;   (first (end seq)))
+
+;; (defun extend (seq elem)
+;;   "Extends a list with the given element, by putting it in
+;; the (rest) of the last element of the sequence."
+;;   (when (pair? seq)
+;;     (define e (end seq))
+;;     (mutate e (pair (first e) elem)))
+;;   seq)
+
+;; (defun incr (val)
+;;   "Adds one to the argument."
+;;   (+ val 1))
+
+;; (defun decr (val)
+;;   "Subtracts one from the argument."
+;;   (- val 1))
+
+;; (defun append (seq elem)
+;;   "Appends an element to a sequence, by extendeing the list
+;; with (pair elem nil)."
+;;   (extend seq (pair elem nil)))
+
+;; (defun length (seq)
+;;   "Returns the length of the given sequence."
+;;   (if (nil? seq)
+;;       0
+;;     (incr (length (rest seq)))))
+
+;; (defmacro n-times (@times @action)
+;;   "Executes @action @times times."
+;;   (unless (<= (eval @times) 0)
+;;     (eval @action)
+;;     (apply n-times (list (list - @times 1) @action))))
+
+;; (defmacro for (@symbol @from @to :rest @for-body)
+;;   "Designed to resemble a C style for loop. It takes a symbol as
+;; well as its starting number and end number and executes the
+;; @for-body with the defined symbol for all numbers between @from
+;; to @to, where @to is exclusive."
+;;   (if (< (eval @from) (eval @to))
+;;       (macro-define @op incr)
+;;     (if (> (eval @from) (eval @to))
+;;         (macro-define @op decr)
+;;       (macro-define @op nil)))
+;;   (when @op
+;;      (macro-define (eval @symbol) (eval @from))
+;;      (eval (pair prog @for-body))
+;;      (eval (extend (list for @symbol (@op @from) @to) @for-body))))
+
+;; (defun range (:keys from :defaults-to 0 to)
+;;   "Returns a sequence of numbers starting with the number defined
+;; by the key 'from' and ends with the number defined in 'to'."
+;;   (when (< from to)
+;;       (pair from (range :from (+ 1 from) :to to))))
+
+;; (defun range-while (:keys from :defaults-to 0 to)
+;;   "Returns a sequence of numbers starting with the number defined
+;; by the key 'from' and ends with the number defined in 'to'."
+;;   (define result (list (copy from)))
+;;   (define head result)
+;;   (mutate from (incr from))
+;;   (while (< from to)
+;;     (prog
+;;      (mutate head (pair (first head) (pair (copy from) nil)))
+;;      (define head (rest head))
+;;      (mutate from (incr from))))
+;;   result)
+
+;; (defun map (fun seq)
+;;   "Takes a function and a sequence as arguments and returns a new
+;; sequence which contains the results of using the first sequences
+;; elemens as argument to that function."
+;;   (if (nil? seq)
+;;       seq
+;;     (pair (fun (first seq))
+;;           (map fun (rest seq)))))
+
+;; (defun reduce (fun seq)
+;;   "Takes a function and a sequence as arguments and applies the
+;; function to the argument sequence. This only works correctly if
+;; the given function accepts a variable amount of parameters. If
+;; your funciton is limited to two arguments, use `reduce-binary'
+;; instead."
+;;   (apply fun seq))
+
+;; (defun reduce-binary (fun seq)
+;;   "Takes a function and a sequence as arguments and applies the
+;; function to the argument sequence. reduce-binary applies the
+;; arguments `pair-wise' which means it works with binary functions
+;; as compared to `reduce'."
+;;   (if (nil? (rest seq))
+;;       (first seq)
+;;     (fun (first seq)
+;;          (reduce-binary fun (rest seq)))))
+
+;; (defun filter (fun seq)
+;;   "Takes a function and a sequence as arguments and applies the
+;; function to every value in the sequence. If the result of that
+;; funciton application returns a truthy value, the original value is
+;; added to a list, which in the end is returned."
+;;   (when seq
+;;     (if (fun (first seq))
+;;         (pair (first seq)
+;;               (filter fun (rest seq)))
+;;       (filter fun (rest seq)))))
+
+;; (defun printf (:keys sep :defaults-to " " end :defaults-to "\n" :rest args)
+;;   "A wrapper for the built-in (print) that accepts a variable number
+;; of arguments and also provides keywords for specifying the printed
+;; separators between the arguments and what should be printed after the
+;; las argument."
+;;   (defmacro printf-quoted (:keys @sep @end :rest @args)
+;;     (if (nil? @args)
+;;         (prog (print (eval @end)) nil)
+;;       (prog
+;;        (print (first @args))
+;;        (unless (nil? (rest @args))
+;;          (print (eval @sep)))
+;;        (eval (pair printf-quoted
+;;               (extend (list :@sep (eval @sep) :@end (eval @end)) (rest @args)))))))
+
+;;   (eval (pair printf-quoted (extend (list :@sep (eval sep) :@end (eval end)) args))))
+
+;; (defmacro pe (@expr)
+;;   (printf @expr "evaluates to" (eval @expr)))

bin/test.slime

@@ -1,12 +1,29 @@
 
 (defun make-vector (x y z)
-    (let ((local-x x)
-          (local-y y)
-          (local-z z))
-      (lambda ()
-        local-x)))
+  (let ((local-x x)
+        (local-y y)
+        (local-z z)
+        (defun (macro (@name @params :rest @body)
+                      (eval (pair 'define-upwards (pair @name (pair (pair 'lambda (pair @params @body)) nil)))))))
+
+    (defun set-x (new-x) (mutate local-x new-x))
+    (defun set-y (new-y) (mutate local-y new-y))
+    (defun set-z (new-z) (mutate local-z new-z))
+
+    (defun dispatch (message)
+      (if (= message ::get-x)
+          local-x
+        (if (= message ::set-x)
+            set-x
+          nil)))
+
+    (break)
+    dispatch))
 
 (define v (make-vector 1 2 3))
-(print (v))
+
+(print (v ::get-x))
+((v ::set-x) 19)
+(print (v ::get-x))
 
 (read " ")

src/ast.cpp

@@ -109,6 +109,7 @@ void append_to_keyword_argument_list(Keyword_Arguments* args,
     append_to_Ast_Node_array_list(args->values, default_value);
 }
 
+struct Environment;
 
 struct Function {
     bool is_macro;
@@ -117,10 +118,10 @@ struct Function {
     Keyword_Arguments*    keyword_arguments;
     // rest_argument will be nullptr if no rest argument is declared
     char*                 rest_argument;
-    struct Ast_Node* body; // implicit prog
+    Ast_Node* body; // implicit prog
+    Environment* parent_environment; // we are doing closures now!!
 };
 
-struct Environment;
 
 struct CFunction {
     std::function<Ast_Node*(Ast_Node*, Environment*)> function;

src/built_ins.cpp

@@ -324,7 +324,7 @@ void load_built_ins_into_environment(Environment* env) {
 
             return value;
         });
-    defun("macro-define", cLambda {
+    defun("define-upwards", cLambda {
             try {
                 arguments_length = list_length(arguments);
             }
@@ -345,15 +345,50 @@ void load_built_ins_into_environment(Environment* env) {
                 report_error(Error_Type::Type_Missmatch);
             }
 
+            if (!env->parent) {
+                report_error(Error_Type::Unknown_Error);
+            }
+
+
             Ast_Node* value = arguments->value.pair->rest->value.pair->first;
             try {
                 value = eval_expr(value, env);
             }
 
-            define_macro_symbol(symbol, value, env);
+            define_symbol(symbol, value, env->parent);
 
             return value;
         });
+    // defun("macro-define", cLambda {
+    //         try {
+    //             arguments_length = list_length(arguments);
+    //         }
+
+    //         if (arguments_length != 2) {
+    //             report_error(Error_Type::Wrong_Number_Of_Arguments);
+    //         }
+
+    //         Ast_Node* symbol = arguments->value.pair->first;
+
+    //         if (symbol->type == Ast_Node_Type::Pair) {
+    //             try {
+    //                 symbol = eval_expr(symbol, env);
+    //             }
+    //         }
+
+    //         if (symbol->type != Ast_Node_Type::Symbol) {
+    //             report_error(Error_Type::Type_Missmatch);
+    //         }
+
+    //         Ast_Node* value = arguments->value.pair->rest->value.pair->first;
+    //         try {
+    //             value = eval_expr(value, env);
+    //         }
+
+    //         define_macro_symbol(symbol, value, env);
+
+    //         return value;
+    //     });
     defun("mutate", cLambda {
             try {
                 evaluated_arguments = eval_arguments(arguments, env, &arguments_length);
@@ -500,7 +535,7 @@ void load_built_ins_into_environment(Environment* env) {
             if (arguments_length < 1)
                 report_error(Error_Type::Wrong_Number_Of_Arguments);
 
-            Environment* let_env = create_child_environment(env, Environment_Type::Let);
+            Environment* let_env = create_child_environment(env);
             Ast_Node* bindings = arguments->value.pair->first;
             while (true) {
                 if (bindings->type == Ast_Node_Type::Nil) {
@@ -564,6 +599,7 @@ void load_built_ins_into_environment(Environment* env) {
             /* if (lispOperator->value.built_in_function->type == Built_In_Macro) { */
             /* function->is_macro = true; */
             /* } else { */
+            function->parent_environment = env;
             function->is_macro = false;
             /* } */
 
@@ -614,6 +650,7 @@ void load_built_ins_into_environment(Environment* env) {
                 report_error(Error_Type::Wrong_Number_Of_Arguments);
 
             Function* function = new(Function);
+            function->parent_environment = env;
             function->is_macro = true;
 
             // if parameters were specified
@@ -962,7 +999,7 @@ void load_built_ins_into_environment(Environment* env) {
 }
 
 Environment* create_built_ins_environment() {
-    Environment* ret = create_child_environment(nullptr, Environment_Type::Let);
+    Environment* ret = create_child_environment(nullptr);
     load_built_ins_into_environment(ret);
     return ret;
 }

src/env.cpp

@@ -1,12 +1,5 @@
-enum struct Environment_Type {
-    Let,
-    Lambda,
-    Macro,
-};
-
 struct Environment {
     struct Environment* parent;
-    Environment_Type    type;
 
     int       capacity;
     int       next_index;
@@ -15,12 +8,11 @@ struct Environment {
     Ast_Node** values;
 };
 
-Environment* create_child_environment(Environment* parent, Environment_Type type) {
+Environment* create_child_environment(Environment* parent) {
     Environment* env = new(Environment);
 
     int start_capacity = 16;
 
-    env->type       = type;
     env->parent     = parent;
     env->capacity   = start_capacity;
     env->next_index = 0;
@@ -30,19 +22,19 @@ Environment* create_child_environment(Environment* parent, Environment_Type type
     return env;
 }
 
-Environment* create_empty_environment(Environment_Type type) {
-    return create_child_environment(nullptr, type);
+Environment* create_empty_environment() {
+    return create_child_environment(nullptr);
 }
 
 void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) {
-    if (env->type == Environment_Type::Macro) {
-        // NOTE(Felix): we know we have a parent because every
-        // environment has a parent except the top level environment.
-        // However the top level environment is not a let-environment,
-        // so we would not land here
-        define_symbol(symbol, value, env->parent);
-        return;
-    }
+    // if (env->type == Environment_Type::Macro) {
+    //     // NOTE(Felix): we know we have a parent because every
+    //     // environment has a parent except the top level environment.
+    //     // However the top level environment is not a let-environment,
+    //     // so we would not land here
+    //     define_symbol(symbol, value, env->parent);
+    //     return;
+    // }
 
     // NOTE(Felix): right now we are simply adding the symol at the
     // back of the list without checking if it already exists but are
@@ -60,16 +52,16 @@ void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) {
     ++env->next_index;
 }
 
-void define_macro_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) {
-    if (env->type != Environment_Type::Macro) {
-        create_error(Error_Type::Unknown_Error, symbol->sourceCodeLocation);
-        return;
-    }
+// void define_macro_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) {
+//     if (env->type != Environment_Type::Macro) {
+//         create_error(Error_Type::Unknown_Error, symbol->sourceCodeLocation);
+//         return;
+//     }
 
-    env->type = Environment_Type::Lambda;
-    define_symbol(symbol, value, env);
-    env->type = Environment_Type::Macro;
-}
+//     env->type = Environment_Type::Lambda;
+//     define_symbol(symbol, value, env);
+//     env->type = Environment_Type::Macro;
+// }
 
 void print_environment(Environment* env);
 
@@ -80,41 +72,41 @@ Ast_Node* lookup_symbol_in_this_envt(Symbol* sym, Environment* env) {
     return nullptr;
 }
 
-Ast_Node* lookup_symbol_from_lambda_env(Symbol* sym, Environment* env) {
-    Ast_Node* result;
-    do {
-        if (env->type != Environment_Type::Lambda) {
-            result = lookup_symbol_in_this_envt(sym, env);
-            if (result) return result;
-        }
-        env = env->parent;
-    } while (env);
-    return nullptr;
-}
-
-Ast_Node* lookup_symbol_from_let_or_macro_env(Symbol* sym, Environment* env) {
-    Ast_Node* result;
-    do {
-        result = lookup_symbol_in_this_envt(sym, env);
-        if (result) return result;
-        if (env->type == Environment_Type::Lambda)
-            break;
-
-        env = env->parent;
-    } while (env);
-
-    if (env) {
-        do {
-            if (env->type != Environment_Type::Lambda) {
-                result = lookup_symbol_in_this_envt(sym, env);
-                if (result) return result;
-            }
-            env = env->parent;
-        } while (env);
-    }
-
-    return nullptr;
-}
+// Ast_Node* lookup_symbol_from_lambda_env(Symbol* sym, Environment* env) {
+//     Ast_Node* result;
+//     do {
+//         if (env->type != Environment_Type::Lambda) {
+//             result = lookup_symbol_in_this_envt(sym, env);
+//             if (result) return result;
+//         }
+//         env = env->parent;
+//     } while (env);
+//     return nullptr;
+// }
+
+// Ast_Node* lookup_symbol_from_let_or_macro_env(Symbol* sym, Environment* env) {
+//     Ast_Node* result;
+//     do {
+//         result = lookup_symbol_in_this_envt(sym, env);
+//         if (result) return result;
+//         if (env->type == Environment_Type::Lambda)
+//             break;
+
+//         env = env->parent;
+//     } while (env);
+
+//     if (env) {
+//         do {
+//             if (env->type != Environment_Type::Lambda) {
+//                 result = lookup_symbol_in_this_envt(sym, env);
+//                 if (result) return result;
+//             }
+//             env = env->parent;
+//         } while (env);
+//     }
+
+//     return nullptr;
+// }
 
 Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) {
     // first check current environment
@@ -125,11 +117,7 @@ Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) {
         return result;
 
     if (env->parent) {
-        if (env->type == Environment_Type::Lambda) {
-            result = lookup_symbol_from_lambda_env(sym, env->parent);
-        } else {
-            result = lookup_symbol_from_let_or_macro_env(sym, env->parent);
-        }
+        result = lookup_symbol(node, env->parent);
 
         if (result)
             return result;
@@ -142,14 +130,6 @@ Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) {
         return create_ast_node_t();
     }
 
-    // we should not need this anymore when we have c lambdas as built
-    // in functions
-
-    /* result = create_ast_node_built_in_function(sym->identifier); */
-    /* result->sourceCodeLocation = node->sourceCodeLocation; */
-    /* if (result) */
-    /*     return result; */
-
     create_error(Error_Type::Symbol_Not_Defined, node->sourceCodeLocation);
     /* printf("%s\n", sym->identifier); */
     return nullptr;
@@ -170,12 +150,12 @@ void print_environment_indent(Environment* env, int indent) {
     if (env->parent) {
         print_indent(indent);
         printf("parent");
-        if (env->parent->type == Environment_Type::Lambda)
-            printf(" (lambda)");
-        else if (env->parent->type == Environment_Type::Macro)
-            printf(" (macro)");
-        else if (env->parent->type == Environment_Type::Let)
-            printf(" (let)");
+        // if (env->parent->type == Environment_Type::Lambda)
+        //     printf(" (lambda)");
+        // else if (env->parent->type == Environment_Type::Macro)
+        //     printf(" (macro)");
+        // else if (env->parent->type == Environment_Type::Let)
+        //     printf(" (let)");
         printf(":\n");
         print_environment_indent(env->parent, indent+4);
     }

src/eval.cpp

@@ -6,7 +6,8 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E
     // switching between "define_symbol" and "define_macro_symbol" all
     // the time
 
-    Environment* new_env = create_child_environment(parent, Environment_Type::Lambda);
+    // Environment* new_env = create_child_environment(parent, Environment_Type::Lambda);
+    Environment* new_env = create_child_environment(function->parent_environment);
 
     // positional arguments
     for (int i = 0; i < function->positional_arguments->next_index; ++i) {
@@ -145,8 +146,6 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E
 
         // don't have to check every time if it is macro environment or
         // not
-        if (function->is_macro)
-            new_env->type = Environment_Type::Macro;
 
         try {
             result = eval_expr(function->body, new_env);

src/main.cpp

@@ -30,7 +30,7 @@ Ast_Node* interprete_file (char* file_name) {
         program = parse_program(file_name, file_content);
     }
 
-    Environment* env = create_empty_environment(Environment_Type::Let);
+    Environment* env = create_empty_environment();
     load_built_ins_into_environment(env);
 
     try {
@@ -50,7 +50,7 @@ Ast_Node* interprete_file (char* file_name) {
 int interprete_stdin () {
     printf("Welcome to the lispy interpreter.\n");
     char* line;
-    Environment* env = create_empty_environment(Environment_Type::Let);
+    Environment* env = create_empty_environment();
     load_built_ins_into_environment(env);
 
     built_in_load("pre.slime", env);