feat: add REPL

Author: nos1dot618

README.md

@@ -33,7 +33,7 @@ lbd [options]
 ### Options
 
 ```
--f, --file <filename>   Specify input source file to run
+-f, --file <filepath>   Specify input source filepath to run
 -h, --help              Show this help message and exit
 -d, --debug             Enable debug mode
 -r, --repl              Run in interactive REPL mode

examples/std.lbd

@@ -1,5 +1,3 @@
--- TODO: Support for `use`
-
 -- booleans and conditions
 true: Bool = \x: Any. \y: Any. x
 false: Bool = \x: Any. \y: Any. y

examples/test.lbd

@@ -1,17 +1,3 @@
--- Define Pi as constant
-pi: Float = 3.14
+use "examples/std.lbd"
 
--- Define function to calculate square
-square: Float -> Float = \x: Float. (mul x x)
-
--- Define function to calculate area of circle
-area_of_circle: Float -> Float = \r: Float.
-    (mul pi (square r))
-
--- Define function to calculate volume of cylinder
-volume_of_cylinder: Float -> Float -> Float = \r: Float.
-	\h: Float. (mul (area_of_circle r) h)
-
--- Calculate the volume of a cylinder
-(print "Volume of cylinder is: ")
-(print (volume_of_cylinder 5.0 10.0))
+(print (eq 1 0))

include/lbd/intp/interpreter.h

@@ -18,6 +18,8 @@ namespace intp::interp {
         std::shared_ptr<Env> env; /// Environment at the time of Lambda Expression creation
 
         friend std::ostream &operator<<(std::ostream &os, const Closure &closure);
+
+        [[nodiscard]] std::string to_string() const;
     };
 
     using Value = std::variant<double, std::string, Closure, NativeFunction>;
@@ -31,9 +33,13 @@ namespace intp::interp {
         Impl impl;
 
         friend std::ostream &operator<<(std::ostream &os, const NativeFunction &native_fn);
+
+        [[nodiscard]] std::string to_string() const;
     };
 
     /// Pretty print a runtime value for REPL/diagnostics
+    std::string val_to_string(const Value &value);
+
     std::ostream &operator<<(std::ostream &os, const Value &value);
 
     /// Lazy Thunk (call-by-need)
@@ -71,7 +77,7 @@ namespace intp::interp {
 
         void bind(const std::string &name, std::shared_ptr<Thunk> thunk);
 
-        void dump(std::ostream &os, bool force) const;
+        std::vector<std::vector<std::string> > to_vector(bool force) const;
     };
 
     Value eval_expr(const fe::ast::Expression &expr, std::shared_ptr<Env> env);

include/lbd/term.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <iostream>
+#include <vector>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+inline bool enable_virtual_terminal() {
+#if defined(_WIN32)
+    const HANDLE output_handle = GetStdHandle(STD_OUTPUT_HANDLE); // NOLINT(*-misplaced-const)
+    if (output_handle == INVALID_HANDLE_VALUE) {
+        return false;
+    }
+    DWORD dwMode = 0;
+    if (!GetConsoleMode(output_handle, &dwMode)) {
+        return false;
+    }
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    if (!SetConsoleMode(output_handle, dwMode)) {
+        return false;
+    }
+#endif
+    return true;
+}
+
+namespace colors {
+    constexpr auto RESET = "\033[0m";
+    constexpr auto RED = "\033[31m";
+    constexpr auto GREEN = "\033[32m";
+    constexpr auto YELLOW = "\033[33m";
+    constexpr auto BLUE = "\033[34m";
+    constexpr auto CYAN = "\033[36m";
+    constexpr auto WHITE = "\033[37m";
+    constexpr auto GREY = "\033[38;5;200m";
+}
+
+inline void print_table_row(const std::vector<std::string> &row, const std::vector<size_t> &widths,
+                            const std::string &color = "") {
+    std::cout << color;
+    for (size_t i = 0; i < row.size(); ++i) {
+        std::cout << std::setw(static_cast<int>(widths[i])) << std::left << row[i] << "  ";
+    }
+    std::cout << colors::RESET << std::endl;
+}
+
+inline void print_table(const std::vector<std::string> &headers, const std::vector<std::vector<std::string> > &data,
+                        const std::string &color = colors::CYAN) {
+    std::vector<size_t> widths(headers.size(), 0);
+    for (size_t i = 0; i < headers.size(); ++i) {
+        widths[i] = headers[i].size();
+    }
+    for (const auto &row: data) {
+        for (size_t i = 0; i < row.size(); ++i) {
+            if (static_cast<int>(row[i].size()) > widths[i]) {
+                widths[i] = row[i].size();
+            }
+        }
+    }
+    print_table_row(headers, widths, color);
+    for (size_t i = 0; i < headers.size(); ++i) {
+        std::cout << std::string(widths[i], '-') << "  ";
+    }
+    std::cout << std::endl;
+    for (const auto &row: data) {
+        print_table_row(row, widths);
+    }
+}

src/cmd.cpp

@@ -4,7 +4,7 @@ namespace cmd {
     void print_help(std::ostream &os, const std::string &program_name) {
         os << "usage: " << program_name << " [options]\n\n"
                 << "options:\n"
-                << "  -f, --file <filename>   Specify input source file to run\n"
+                << "  -f, --file <filepath>   Specify input source filepath to run\n"
                 << "  -h, --help              Show this help message and exit\n"
                 << "  -d, --debug             Enable debug mode\n"
                 << "  -r, --repl              Run in interactive REPL node" << std::endl;

src/fe/parser.cpp

@@ -1,8 +1,13 @@
 #include <lbd/fe/loc.h>
+#include <lbd/fe/lexer.h>
 #include <lbd/fe/parser.h>
 #include <lbd/string_escape.h>
+#include <unordered_set>
+#include <filesystem>
 
 namespace fe::parser {
+    static std::unordered_set<std::string> loaded_files;
+
     Parser::Parser(const std::vector<token::Token> &tokens) {
         size_t i = 0;
         program = ast::Program{build_ast(tokens, i)};
@@ -137,26 +142,53 @@ namespace fe::parser {
         return ast::DefAstNode{def_name, typ, std::move(expr), loc};
     }
 
+    static std::string get_abs_path(const std::string &path) {
+        return std::filesystem::absolute(path).string();
+    }
+
+    static void process_use_file(std::vector<ast::AstNode> &nodes, const std::string &filepath) {
+        const std::string abs_path = get_abs_path(filepath);
+        if (loaded_files.contains(abs_path)) {
+            // Circular Dependency or Duplicate Load
+            return;
+        }
+        loaded_files.insert(abs_path);
+        auto lexer_v = lexer::Lexer(filepath, lexer::FromFile{});
+        const auto tokens = lexer_v.lex_all();
+        // TODO: Accept Options and Add a debug flag for printing Lexed Tokens
+        for (Parser parser(tokens); auto &node: parser.program.nodes) {
+            nodes.emplace_back(std::move(node));
+        }
+    }
+
     std::vector<ast::AstNode> Parser::build_ast(const std::vector<token::Token> &tokens, size_t &i) {
         std::vector<ast::AstNode> nodes;
         while (!std::holds_alternative<token::Eof>(tokens[i].typ)) {
             const token::Token &tok = tokens[i];
-            nodes.push_back(std::visit([&]<typename T0>(T0 &&) {
+            std::visit([&]<typename T0>(T0 &&) {
                 using T = std::decay_t<T0>;
-                if (std::is_same_v<T, token::Iden>) {
-                    return ast::AstNode{std::move(parse_def_ast_node(tokens, i))};
-                }
-                if (std::is_same_v<T, token::String>
-                    || std::is_same_v<T, token::Float>
-                    || std::is_same_v<T, token::BackwardSlash>
-                    || std::is_same_v<T, token::OpenParen>) {
-                    return ast::AstNode{std::move(parse_expression(tokens, i))};
+                if constexpr (std::is_same_v<T, token::Iden>) {
+                    if (const auto iden_value = std::get<token::Iden>(tokens[i].typ).value; iden_value == "use") {
+                        ++i; // eat "use"
+                        assert_token<token::String>(tokens, i);
+                        const std::string filepath = unescape_string(std::get<token::String>(tokens[i].typ).value);
+                        ++i; // eat <filepath>
+                        process_use_file(nodes, filepath);
+                    } else {
+                        nodes.push_back(ast::AstNode{std::move(parse_def_ast_node(tokens, i))});
+                    }
+                } else if constexpr (std::is_same_v<T, token::String> ||
+                                     std::is_same_v<T, token::Float> ||
+                                     std::is_same_v<T, token::BackwardSlash> ||
+                                     std::is_same_v<T, token::OpenParen>) {
+                    nodes.push_back(ast::AstNode{std::move(parse_expression(tokens, i))});
+                } else {
+                    std::cerr << tok.loc << ": syntax error: unexpected token "
+                            << tok.to_string()
+                            << std::endl;
+                    std::exit(EXIT_FAILURE);
                 }
-                std::cerr << tok.loc << ": syntax error: unexpected token "
-                        << tok.to_string()
-                        << std::endl;
-                std::exit(EXIT_FAILURE);
-            }, tok.typ));
+            }, tok.typ);
         }
         return nodes;
     }

src/intp/interpreter.cpp

@@ -1,14 +1,27 @@
 #include <lbd/intp/interpreter.h>
 #include <lbd/intp/builtins.h>
 #include <lbd/error.h>
+#include <sstream>
 
 namespace intp::interp {
+    [[nodiscard]] std::string Closure::to_string() const {
+        std::ostringstream oss;
+        oss << "<closure: " << param << ">";
+        return oss.str();
+    }
+
     std::ostream &operator<<(std::ostream &os, const Closure &closure) {
-        return os << "<closure: " << closure.param << ">";
+        return os << closure.to_string();
+    }
+
+    [[nodiscard]] std::string NativeFunction::to_string() const {
+        std::ostringstream oss;
+        oss << "<native_fn: " << name << " " << arity << ">";
+        return oss.str();
     }
 
     std::ostream &operator<<(std::ostream &os, const NativeFunction &native_fn) {
-        return os << "<native_fn: " << native_fn.name << " " << native_fn.arity << ">";
+        return os << native_fn.to_string();
     }
 
     static std::ostream &print_loc_prefix(std::ostream &os, const std::optional<fe::loc::Loc> &loc) {
@@ -18,6 +31,22 @@ namespace intp::interp {
         return os;
     }
 
+    std::string val_to_string(const Value &value) {
+        return std::visit([&]<typename T0>(T0 &&arg) {
+            using T = std::decay_t<T0>;
+            if constexpr (std::is_same_v<T, double>) {
+                return std::to_string(arg);
+            } else if constexpr (std::is_same_v<T, std::string>) {
+                return arg;
+            } else if constexpr (std::is_same_v<T, Closure> ||
+                                 std::is_same_v<T, NativeFunction>) {
+                return arg.to_string();
+            } else {
+                STATIC_ASSERT_UNREACHABLE_T(T, "unhandled runtime value");
+            }
+        }, value);
+    }
+
     std::ostream &operator<<(std::ostream &os, const Value &value) {
         std::visit([&]<typename T0>(T0 &&arg) {
             using T = std::decay_t<T0>;
@@ -91,29 +120,29 @@ namespace intp::interp {
         table[name] = std::move(thunk);
     }
 
-    void Env::dump(std::ostream &os, const bool force) const {
+    std::vector<std::vector<std::string> > Env::to_vector(const bool force) const {
+        std::vector<std::vector<std::string> > vec;
+        vec.reserve(table.size());
         for (const auto &[name, thunk]: table) {
-            os << "  " << name << " = ";
+            std::string val_str = "<thunk: unevaluated>";
             try {
                 if (force) {
                     const Value &val = thunk->force();
-                    os << val;
-                } else {
-                    if (thunk->cached) {
-                        os << *(thunk->cached); // already computed
-                    } else {
-                        os << "<thunk: unevaluated>";
-                    }
+                    val_str = val_to_string(val);
+                } else if (thunk->cached) {
+                    val_str = val_to_string(*thunk->cached); // already computed
                 }
-            } catch (const std::exception &ex) {
-                os << "<thunk: unevaluated>";
+            } catch (const std::exception &) {
+                val_str = "<thunk: error>";
             }
-            os << std::endl;
+            vec.push_back({name, val_str});
         }
         if (parent) {
-            os << "info: parent environment" << std::endl;
-            parent->dump(os, force);
+            auto parent_vec = parent->to_vector(force);
+            vec.insert(vec.end(), std::make_move_iterator(parent_vec.begin()),
+                       std::make_move_iterator(parent_vec.end()));
         }
+        return vec;
     }
 
     static Value eval_iden_ast_node(const fe::ast::IdenAstNode &iden_ast_node, const std::shared_ptr<Env> &env) {