feat: signal side effects in interpreter

Author: nos1dot618

examples/list.lbd

@@ -1,4 +1,4 @@
-a: List = (list "Hello")
+a: List = (list)
 (print a)
 
 (list_append a "World")

include/lbd/intp/interpreter.h

@@ -51,8 +51,14 @@ namespace intp::interp {
         friend std::ostream &operator<<(std::ostream &os, const Value &value);
     };
 
+    struct ResultOptions {
+        bool side_effects = false;
+
+        void interpolate(const ResultOptions &result_options_);
+    };
+
     struct NativeFunction {
-        using Impl = std::function<Value(
+        using Impl = std::function<std::pair<Value, ResultOptions>(
             const std::vector<std::shared_ptr<Thunk> > &, const std::shared_ptr<Env> &)>;
 
         int arity;
@@ -112,6 +118,7 @@ namespace intp::interp {
     struct Result {
         std::shared_ptr<Env> global_env;
         Value value;
+        ResultOptions options = {};
     };
 
     Result interpret(fe::ast::Program &program, std::optional<std::shared_ptr<Env> > global_env = std::nullopt,

src/intp/builtins.cpp

@@ -7,68 +7,73 @@ namespace intp::interp {
     static NativeFunction make_print() {
         const std::string name = "print";
         return {
-            -1, name, [](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            -1, name, [](const std::vector<std::shared_ptr<Thunk> > &args,
+                         const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 for (auto &arg: args) {
                     const Value &value = arg->force();
                     std::cout << value;
                 }
-                return Value{static_cast<double>(0)};
+                return std::make_pair(Value{static_cast<double>(0)}, ResultOptions{.side_effects = true});
             }
         };
     }
 
     static NativeFunction make_add() {
         const std::string name = "add";
         return {
-            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 const Value &value1 = args[0]->force();
                 const Value &value2 = args[1]->force();
                 if (!std::holds_alternative<double>(value1) || !std::holds_alternative<double>(value2)) {
                     options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
                                            "\n", name, " signature: Float -> Float -> Float");
                 }
                 const double result = std::get<double>(value1) + std::get<double>(value2);
-                return Value{result};
+                return std::make_pair(Value{result}, ResultOptions{});
             }
         };
     }
 
     static NativeFunction make_sub() {
         const std::string name = "sub";
         return {
-            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 const Value &value1 = args[0]->force();
                 const Value &value2 = args[1]->force();
                 if (!std::holds_alternative<double>(value1) || !std::holds_alternative<double>(value2)) {
                     options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
                                            "\n", name, " signature: Float -> Float -> Float");
                 }
                 const double result = std::get<double>(value1) - std::get<double>(value2);
-                return Value{result};
+                return std::make_pair(Value{result}, ResultOptions{});
             }
         };
     }
 
     static NativeFunction make_mul() {
         const std::string name = "mul";
         return {
-            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 const Value &value1 = args[0]->force();
                 const Value &value2 = args[1]->force();
                 if (!std::holds_alternative<double>(value1) || !std::holds_alternative<double>(value2)) {
                     options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
                                            "\n", name, " signature: Float -> Float -> Float");
                 }
                 const double result = std::get<double>(value1) * std::get<double>(value2);
-                return Value{result};
+                return std::make_pair(Value{result}, ResultOptions{});
             }
         };
     }
 
     static NativeFunction make_cmp() {
         const std::string name = "cmp";
         return {
-            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 const Value &value1 = args[0]->force();
                 const Value &value2 = args[1]->force();
                 if (!std::holds_alternative<double>(value1) || !std::holds_alternative<double>(value2)) {
@@ -78,15 +83,16 @@ namespace intp::interp {
                 const double num1 = std::get<double>(value1);
                 const double num2 = std::get<double>(value2);
                 const int result = num1 < num2 ? -1 : num1 > num2 ? 1 : 0;
-                return Value{static_cast<double>(result)};
+                return std::make_pair(Value{static_cast<double>(result)}, ResultOptions{});
             }
         };
     }
 
     static NativeFunction make_if_zero() {
         const std::string name = "if_zero";
         return {
-            3, name, [name](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            3, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 const Value &cond_value = args[0]->force();
                 if (!std::holds_alternative<double>(cond_value)) {
                     options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
@@ -96,9 +102,9 @@ namespace intp::interp {
                 }
                 // Lazy branching: only force the chosen clause
                 if (const double cond = std::get<double>(cond_value); cond == 0.0) {
-                    return args[1]->force();
+                    return std::make_pair(Value{args[1]->force()}, ResultOptions{});
                 }
-                return args[2]->force();
+                return std::make_pair(Value{args[2]->force()}, ResultOptions{});
             }
         };
     }
@@ -108,8 +114,9 @@ namespace intp::interp {
     }
 
     static Value list_get(const std::shared_ptr<List> &list_v, size_t index) {
-        if (index >= list_v->elements.size())
-            throw std::out_of_range("list index out of range");
+        if (index >= list_v->elements.size()) {
+            options_v.logger.error({}, "runtime error: list index out of range, index is ", index);
+        }
         return list_v->elements[index];
     }
 
@@ -120,20 +127,66 @@ namespace intp::interp {
     static NativeFunction make_list() {
         const std::string name = "list";
         return {
-            -1, name, [](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            -1, name, [](const std::vector<std::shared_ptr<Thunk> > &args,
+                         const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 std::vector<Value> values;
                 for (auto &arg: args) {
                     values.push_back(arg->force());
                 }
-                return make_list_obj(values);
+                return std::make_pair(Value{make_list_obj(values)}, ResultOptions{});
+            }
+        };
+    }
+
+    static NativeFunction make_list_size() {
+        const std::string name = "list_size";
+        return {
+            1, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
+                const Value &arg0 = args[0]->force();
+                if (!std::holds_alternative<std::shared_ptr<List> >(arg0)) {
+                    options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
+                                           "\n", name,
+                                           " signature: List -> Float""\n"
+                                           "runtime error: expected <List> got ", arg0);
+                }
+                const auto list_v = std::get<std::shared_ptr<List> >(arg0);
+                return std::make_pair(Value{static_cast<double>(list_v->elements.size())}, ResultOptions{});
+            }
+        };
+    }
+
+    static NativeFunction make_list_get() {
+        const std::string name = "list_get";
+        return {
+            // TODO: Add type checker to replace this manual approach
+            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
+                const Value &arg0 = args[0]->force();
+                if (!std::holds_alternative<std::shared_ptr<List> >(arg0)) {
+                    options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
+                                           "\n", name,
+                                           " signature: List -> Float -> List""\n"
+                                           "runtime error: expected <List> got ", arg0);
+                }
+                const Value &arg1 = args[1]->force();
+                if (!std::holds_alternative<double>(arg1)) {
+                    options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
+                                           "\n", name,
+                                           " signature: List -> Float -> List""\n"
+                                           "runtime error: expected <Float> got ", arg1);
+                }
+                return std::make_pair(Value{list_get(std::get<std::shared_ptr<List> >(arg0), std::get<double>(arg1))},
+                                      ResultOptions{});
             }
         };
     }
 
     static NativeFunction make_list_append() {
         const std::string name = "list_append";
         return {
-            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args, const std::shared_ptr<Env> &) -> Value {
+            2, name, [name](const std::vector<std::shared_ptr<Thunk> > &args,
+                            const std::shared_ptr<Env> &) -> std::pair<Value, ResultOptions> {
                 const Value &arg0 = args[0]->force();
                 if (!std::holds_alternative<std::shared_ptr<List> >(arg0)) {
                     options_v.logger.error({}, "runtime error: wrong arguments provided to native function ", name,
@@ -143,7 +196,7 @@ namespace intp::interp {
                 }
                 auto list_v = std::get<std::shared_ptr<List> >(arg0);
                 list_append(list_v, args[1]->force());
-                return list_v;
+                return std::make_pair(Value{list_v}, ResultOptions{});
             }
         };
     }
@@ -158,6 +211,8 @@ namespace intp::interp {
             {make_cmp()},
             {make_if_zero()},
             {make_list()},
+            {make_list_size()},
+            {make_list_get()},
             {make_list_append()}
         };
     }

src/intp/interpreter.cpp

@@ -6,6 +6,7 @@
 
 namespace intp::interp {
     static options::Options options_v;
+    static ResultOptions global_result_options;
 
     [[nodiscard]] std::string Closure::to_string() const {
         std::ostringstream oss;
@@ -52,6 +53,10 @@ namespace intp::interp {
         return os << value.to_string();
     }
 
+    void ResultOptions::interpolate(const ResultOptions &result_options_) {
+        side_effects |= result_options_.side_effects;
+    }
+
     std::ostream &operator<<(std::ostream &os, const List &list) {
         return os << list.to_string();
     }
@@ -210,18 +215,33 @@ namespace intp::interp {
             // If there are no frames left, that's unexpected (shouldn't happen), bail.
             if (frames.empty()) {
                 options_v.logger.error(call_loc, "internal error: no function frame to apply");
-                std::exit(EXIT_FAILURE);
             }
+            // Work on the top-most frame
+            Value current_fn = frames.back();
+            std::optional<Value> resultant_value;
             // If we've consumed all available Argument Thunks:
             if (idx >= work_args.size()) {
                 // If top frame is a function, and we have no more args to feed it,
                 // return that function (partial application) or its value as-is.
-                // If it's not a function (shouldn't happen), return it as value.
-                return frames.back();
+                if (std::holds_alternative<std::shared_ptr<NativeFunction> >(current_fn)) {
+                    // Allow arity==0 and arity==-1 (variadic) to execute with zero args.
+                    if (const auto &native_fn = *std::get<std::shared_ptr<NativeFunction> >(current_fn);
+                        native_fn.arity == 0 || native_fn.arity == -1) {
+                        std::vector<std::shared_ptr<Thunk> > slice; // empty
+                        auto [value, result_options] = native_fn.impl(slice, call_site_env);
+                        global_result_options.interpolate(result_options);
+                        return value;
+                    }
+                    // Non-zero arity native function but no args left: partial application (return the function)
+                    return current_fn;
+                }
+                if (std::holds_alternative<Closure>(current_fn)) {
+                    // Closures require one argument; with none left, this is a partial application (return the closure).
+                    return current_fn;
+                }
+                // It's not a function (shouldn't happen), return it as value.
+                return current_fn;
             }
-            // Work on the top-most frame
-            Value current_fn = frames.back();
-            std::optional<Value> resultant_value;
             // Closure case: Closure consumes exactly one Argument (its Param)
             if (std::holds_alternative<Closure>(current_fn)) {
                 const auto [param, body, env] = std::get<Closure>(current_fn);
@@ -232,8 +252,8 @@ namespace intp::interp {
             }
             // Native Function case: Consumes its arity-many Argument Thunks
             else if (std::holds_alternative<std::shared_ptr<NativeFunction> >(current_fn)) {
-                const auto &[arity, name, impl] = *std::get<std::shared_ptr<NativeFunction> >(current_fn);
-                if (arity != -1) {
+                if (const auto &[arity, name, impl] = *std::get<std::shared_ptr<NativeFunction> >(current_fn);
+                    arity != -1) {
                     if (work_args.size() - idx < arity) {
                         options_v.logger.error(call_loc, "runtime error: native function ", name, " expects ", arity,
                                                " argument(s), found ", work_args.size() - idx);
@@ -243,15 +263,19 @@ namespace intp::interp {
                     for (size_t i = 0; i < arity; ++i) {
                         slice.push_back(work_args[idx + i]);
                     }
-                    resultant_value = impl(slice, call_site_env);
+                    auto [resultant_value_, result_options] = impl(slice, call_site_env);
+                    resultant_value = resultant_value_;
+                    global_result_options.interpolate(result_options);
                     idx += arity;
                 } else {
                     std::vector<std::shared_ptr<Thunk> > slice;
                     slice.reserve(args.size() - idx);
                     for (size_t i = 0; i < args.size() - idx; ++i) {
                         slice.push_back(work_args[idx + i]);
                     }
-                    resultant_value = impl(slice, call_site_env);
+                    auto [resultant_value_, result_options] = impl(slice, call_site_env);
+                    resultant_value = resultant_value_;
+                    global_result_options.interpolate(result_options);
                     idx += args.size() - idx;
                 }
             } else {
@@ -278,7 +302,6 @@ namespace intp::interp {
                 if (idx < work_args.size()) {
                     options_v.logger.error(call_loc, "runtime error: too many arguments applied to non-function value ",
                                            concrete);
-                    std::exit(EXIT_FAILURE);
                 }
                 // No Thunks remaining then concrete Value is the result
                 return concrete;
@@ -327,7 +350,7 @@ namespace intp::interp {
                 }
             }, value);
         }
-        return {*global_env, result_value};
+        return {*global_env, result_value, global_result_options};
     }
 
     void install_builtins(const std::shared_ptr<Env> &env) {

src/repl.cpp

@@ -31,7 +31,8 @@ namespace repl {
         fe::parser::Parser parser(tokens);
         const std::optional<std::shared_ptr<intp::interp::Env> > temp_env = shared_env;
         // Merge loaded_env into shared_env
-        if (const auto [loaded_env, _] = intp::interp::interpret(parser.program, temp_env, {.own_expr = true});
+        if (const auto [loaded_env, _, _result_options] = intp::interp::interpret(
+                parser.program, temp_env, {.own_expr = true});
             loaded_env) {
             if (!shared_env) {
                 shared_env = loaded_env;
@@ -146,8 +147,11 @@ namespace repl {
                 }
 
                 // Interpret
-                const auto [global_env, value] = intp::interp::interpret(
+                const auto [global_env, value, result_options] = intp::interp::interpret(
                     parser_v.program, shared_global_env, options_v);
+                if (result_options.side_effects) {
+                    std::cout << std::endl;
+                }
                 std::cout << colors::GREEN << "=> " << value << colors::RESET << std::endl;
                 shared_global_env = global_env;
             } catch (const ControlledExit &) {