From 20a6f59b3af66b0736bc849c8aa01454953fe0dc Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:12:26 +0800
Subject: [PATCH 01/12] docs: design spec for LLVM AOT compiler

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../specs/2026-06-10-llvm-compiler-design.md  | 154 ++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-06-10-llvm-compiler-design.md

diff --git a/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md b/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
new file mode 100644
index 0000000..06dca7d
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
@@ -0,0 +1,154 @@
+# LLVM AOT Compiler for PseudoCode — Design
+
+Date: 2026-06-10
+Status: Approved for implementation (autonomous session; decisions documented below)
+
+## Goal
+
+Add a compile mode to the project: a `pseudoc` binary that turns a `.ps` source
+file into a native executable using LLVM, with output behavior identical to the
+interpreter (`pseudo file.ps`).
+
+## Approaches considered
+
+1. **Boxed-value AOT with runtime library (chosen).** Compile the AST to LLVM
+   IR where each language operation is a call into an `extern "C"` runtime
+   (`rt_*`) built on top of the existing `Value`, `SymbolTable`, and
+   `BoundMethodValue` code. Link the generated object file against
+   `libpseudort.a` to produce a standalone executable.
+   - Pros: exact semantic parity (reuses the interpreter's own operators,
+     builtins, array/hash methods), tractable codegen, full dynamic typing.
+   - Cons: values remain boxed, so speedups come from removing AST-walking
+     overhead, not from unboxed arithmetic (future work).
+2. **Typed-subset native codegen.** Infer int/float types and emit raw
+   arithmetic. Fast, but supports only a fraction of the language and
+   duplicates semantics; high divergence risk.
+3. **Textual IR emission + clang.** No LLVM library dependency, but fragile,
+   unverifiable IR and a worse foundation. Rejected.
+
+## Architecture
+
+```
+pseudoc (new binary)
+  ├── reuses: lexer, parser, import expansion (refactored out of run())
+  ├── src/compiler.{h,cpp}: Compiler — AST → llvm::Module (LLVM C++ API)
+  └── links output .o with build/libpseudort.a via the system C++ driver
+
+libpseudort.a (new static library)
+  ├── existing objects: pseudo.o, interpreter.o, symboltable.o, node.o, ...
+  └── src/runtime.{h,cpp}: extern "C" rt_* shims + CompiledAlgoValue
+```
+
+### Value representation
+
+All values are `Value*` (LLVM opaque `ptr`). `Value` gains
+`std::enable_shared_from_this<Value>` so the runtime can recover the owning
+`shared_ptr` from a raw pointer. Lifetimes are managed by an **arena frame
+stack** in the runtime: every `rt_*` function that produces a value registers
+its `shared_ptr` in the current frame. Frames are pushed/popped:
+
+- per function call (by `rt_call`),
+- per loop iteration (emitted by codegen), so long-running loops don't grow
+  memory unboundedly. Values that survive (stored in variables, arrays, etc.)
+  are kept alive by the `SymbolTable`/container `shared_ptr`s.
+- `rt_frame_mark()` / `rt_frame_release(mark)` let codegen unwind frames on
+  `break` / `return` edges. Function results are re-registered in the caller's
+  frame.
+
+### Codegen rules (mirror interpreter semantics exactly)
+
+- Each top-level statement of the program body compiles into `main` in order;
+  `Algorithm` definitions compile to LLVM functions `ptr @"ps.algo.N.<name>"()`
+  plus a runtime registration (`rt_define_algo`) at the definition site, so
+  call-before-definition errors behave the same.
+- Variables: always through `rt_get_var` / `rt_set_var` (dynamic scoping via
+  the symbol-table parent chain, exactly like `AlgoValue::execute`).
+- `if`: branch on `stoll(cond->get_num()) == 1` (`rt_cond_eq1`); the statement
+  yields Int 0 when no branch is taken.
+- `for`: replicate `visit_for` — evaluate assign, then step (default Int 1),
+  then end; `step == 0` → "Infinite for loop" error; the latch recomputes
+  `var <- i + step` from the value read at the previous latch (body
+  reassignments of the loop variable are overwritten, matching the
+  interpreter). Condition is float-aware `<=` / `>=` via `rt_for_cond`.
+- `while`: condition `as_int() == 1`; `repeat ... until`: body first, loop
+  while `as_int() == 0`.
+- `break`/`continue`/`return` compile to branches (with frame releases);
+  `return` outside any algorithm behaves like the interpreter (top level:
+  statement result, ignored).
+- Calls: evaluate callee and args to `Value*`, then `rt_call(callee, argv,
+  argc)`:
+  - `CompiledAlgoValue` → arity check ("Too few/Too many arguments" with the
+    same color codes), push scope + frame, bind args, call function pointer.
+  - anything else (builtins, `BoundMethodValue` for array/string/hash methods)
+    → wrap evaluated args in `PrecomputedNode`s and reuse the existing
+    `execute(NodeList, SymbolTable*)` paths unchanged.
+- Member access / array index / array assign: `rt_member_access`, `rt_index`,
+  `rt_index_assign` mirroring `visit_member_access`, `visit_array_access`,
+  `visit_array_assign` (string 1-indexing, hash get/set, array element
+  assignment).
+- Array literals: `rt_array_new` + `rt_array_push`.
+- Errors: any `rt_*` function that produces or receives a `VALUE_ERROR` prints
+  `err->get_num()` (same text the interpreter prints at top level) and exits
+  with status 1. There is no error-value plumbing in generated IR.
+
+### Unsupported in v1 (clean compile-time error)
+
+- `Struct` definitions / instances (`NODE_STRUCTDEF`, member assignment on
+  instances). The compiler reports "compile error: Struct is not supported by
+  the compiler yet" with the source location. `import` works (textual
+  expansion before parsing), but importing a file that defines structs (e.g.
+  `dsa`) hits the same error.
+
+### Intrusive changes to existing code (kept minimal)
+
+1. `Value` inherits `std::enable_shared_from_this<Value>` (value.h).
+2. New `PrecomputedNode` (value.h, since it stores a `shared_ptr<Value>`) and
+   one dispatch case in `Interpreter::visit`.
+3. `expand_imports` (and its `ImportState`) refactored from an anonymous
+   namespace in pseudo.cpp into a small header so the compiler driver can use
+   it.
+
+### Driver & CLI
+
+```
+pseudoc <file.ps> [-o <out>] [--emit-llvm] [--runtime-lib <path>]
+```
+
+- Default output: source basename without extension (`fib.ps` → `fib`).
+- `--emit-llvm` prints the textual IR to stdout and stops.
+- Pipeline: read → expand imports → lex → parse (reuse run()'s error
+  reporting) → codegen → `llvm::verifyModule` → O2 via `PassBuilder` → object
+  file (TargetMachine) → link `c++ obj libpseudort.a -o out`.
+- Runtime archive located via `--runtime-lib`, `$PSEUDO_RT_LIB`, or relative to
+  the `pseudoc` binary (`<dir>/build/libpseudort.a`).
+
+### Build integration
+
+Makefile gets optional targets (not part of default `make`, since LLVM is an
+optional dependency):
+
+- `make runtime` → `build/libpseudort.a` (existing objects + runtime.o).
+- `make compiler` → `pseudoc`, compiled/linked using `llvm-config`
+  (`/opt/homebrew/opt/llvm/bin/llvm-config` fallback). Fails with a clear
+  message if LLVM is missing.
+- `make test-compiler` → end-to-end differential tests.
+
+CI is unchanged (compiler build is optional); new sources follow
+clang-format/clang-tidy rules.
+
+## Testing
+
+Differential end-to-end testing is the core strategy:
+`test/compiler_tests.sh` compiles each supported `.ps` test/benchmark file
+with `pseudoc` and asserts its stdout equals `./pseudo file.ps` stdout.
+Coverage: arithmetic/comparison/logic on ints/floats/strings, arrays +
+methods, hash tables, string indexing, if/for/while/repeat with
+break/continue, recursion (fib), nested functions, argument-count errors,
+runtime errors (index out of range), and the struct compile-error path.
+Existing `make test` (gtest) must keep passing.
+
+## Performance expectation
+
+v1 removes parse/AST-walk overhead but keeps boxed values and symbol-table
+access; expect modest wins over the interpreter. Unboxing/SROA of numeric
+locals is explicitly future work.

From b20fa156c6f02b59974fd113177cd059d6c03fbc Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:13:45 +0800
Subject: [PATCH 02/12] docs: implementation plan for LLVM compiler

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../plans/2026-06-10-llvm-compiler.md         | 146 ++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-06-10-llvm-compiler.md

diff --git a/docs/superpowers/plans/2026-06-10-llvm-compiler.md b/docs/superpowers/plans/2026-06-10-llvm-compiler.md
new file mode 100644
index 0000000..f14e2dc
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-10-llvm-compiler.md
@@ -0,0 +1,146 @@
+# LLVM AOT Compiler Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** A `pseudoc` binary that compiles `.ps` programs to native executables via LLVM, with stdout behavior identical to the interpreter.
+
+**Architecture:** Codegen walks the existing AST and emits LLVM IR where every operation is a call into an `extern "C"` runtime (`rt_*`) layered on the existing `Value`/`SymbolTable` classes; the emitted object file is linked against `build/libpseudort.a`. See `docs/superpowers/specs/2026-06-10-llvm-compiler-design.md`.
+
+**Tech Stack:** C++17 project code, LLVM 21 C++ API (Homebrew, `llvm-config`), GNU make, bash differential tests.
+
+---
+
+### Task 1: Differential test harness (failing first)
+
+**Files:**
+- Create: `test/compiler_tests.sh` (executable)
+- Create: `test/compiler/basics.ps`, `test/compiler/control_flow.ps`, `test/compiler/functions.ps`, `test/compiler/collections.ps`, `test/compiler/errors.ps`
+- Modify: `Makefile` (add `test-compiler` target)
+
+- [ ] **Step 1:** Write `test/compiler_tests.sh`: for each `.ps` in `test/compiler/` plus `test/test_fib.ps`, `test/test_repeat.ps`, `test/test_array_methods.ps`, `test/test_string_index.ps`, run `./pseudo f.ps > expected`, `./pseudoc f.ps -o tmpbin && ./tmpbin > actual`, diff. Exit nonzero on any mismatch. Also assert `./pseudoc test/test_struct.ps` fails with a struct compile error.
+- [ ] **Step 2:** Write the five new `.ps` fixtures covering: int/float/string arithmetic and comparisons, `and/or/not`, unary minus, `^` and `%`; if/else-if chains, for with step (incl. negative), while/repeat with break/continue, nested loops; recursion (fib), functions using caller scope, too-few-args error; arrays (literal, index assign, push/pop/insert/remove/resize/size/back), hash tables (set/get/contains/keys/size), string indexing and concatenation; index-out-of-range error.
+- [ ] **Step 3:** Run `bash test/compiler_tests.sh` — must FAIL (`pseudoc` missing). Commit.
+
+### Task 2: Minimal intrusive changes to interpreter core
+
+**Files:**
+- Modify: `src/value.h` (Value gains `enable_shared_from_this`; add `PrecomputedNode`)
+- Modify: `src/node.h` (add `NODE_PRECOMPUTED` constant)
+- Modify: `src/interpreter.cpp` (`Interpreter::visit` dispatch case returning the precomputed value)
+- Create: `src/imports.h`
+- Modify: `src/pseudo.cpp` (move `ImportState`/`expand_imports` out of anonymous namespace, include `imports.h`)
+
+- [ ] **Step 1:** `class Value : public std::enable_shared_from_this<Value>`; add
+
+```cpp
+class PrecomputedNode : public Node {
+public:
+    explicit PrecomputedNode(std::shared_ptr<Value> _value) : value(_value) {}
+    std::string get_node() override { return "PRECOMPUTED"; }
+    std::string get_type() override { return NODE_PRECOMPUTED; }
+    std::shared_ptr<Value> get_value() { return value; }
+protected:
+    std::shared_ptr<Value> value;
+};
+```
+
+- [ ] **Step 2:** `imports.h` declares `struct ImportState` and `bool expand_imports(const std::string&, const std::string&, ImportState&, std::string&, std::string&);` matching the current pseudo.cpp definitions.
+- [ ] **Step 3:** `make clean && make && make test` — all existing gtests PASS. Run an example to sanity-check. Commit.
+
+### Task 3: Runtime library `libpseudort.a`
+
+**Files:**
+- Create: `src/runtime.h`, `src/runtime.cpp`
+- Modify: `Makefile` (`runtime` target producing `build/libpseudort.a` from all interpreter objects except `shell.o`, plus `runtime.o`)
+
+- [ ] **Step 1:** `runtime.h` — extern "C" ABI (all value params/returns are raw `Value*` kept alive by arena frames):
+
+```cpp
+extern "C" {
+void rt_init();
+void rt_shutdown();
+// constructors
+Value* rt_make_int(int64_t v);
+Value* rt_make_float(double v);
+Value* rt_make_string(const char* s);
+Value* rt_make_none();
+Value* rt_array_new();
+void rt_array_push(Value* arr, Value* v);
+// variables (current scope chain)
+Value* rt_get_var(const char* name);
+Value* rt_set_var(const char* name, Value* v); // returns v
+// operators: op is a single char code matching token types
+Value* rt_bin_op(int op, Value* a, Value* b);
+Value* rt_unary_op(int op, Value* a);
+// control helpers
+int64_t rt_cond_eq1(Value* v);     // stoll(get_num()) == 1  (if)
+int64_t rt_as_int(Value* v);       // as_int()               (while/repeat)
+int64_t rt_for_cond(Value* i, Value* end, Value* step);
+Value* rt_for_step_check(Value* step); // errors on step == 0
+// indexing / members
+Value* rt_index(Value* obj, Value* idx);
+Value* rt_index_assign(Value* obj, Value* idx, Value* v);
+Value* rt_member_access(Value* obj, const char* name);
+// calls
+Value* rt_define_algo(const char* name, Value* (*fn)(), const char* const* args, int64_t nargs);
+Value* rt_call(Value* callee, Value** argv, int64_t argc);
+// frames
+int64_t rt_frame_mark();
+void rt_frame_release(int64_t mark);
+Value* rt_keep(Value* v, int64_t mark); // re-register v in frame `mark`-1 (survives release)
+}
+```
+
+- [ ] **Step 2:** Implement in runtime.cpp: global `std::vector<std::vector<std::shared_ptr<Value>>> frames` and `std::vector<std::unique_ptr<SymbolTable>> scopes` (global scope created by `rt_init`); `CompiledAlgoValue : Value` holding `Value*(*fn)()` and arg names; `rt_call` dispatch (compiled → arity check with interpreter's exact colored error strings, new scope + frame, bind args, invoke; otherwise wrap args in `PrecomputedNode` and call `callee->execute(nodes, current_scope)`). Binary/unary ops call the existing `operator+` etc. on `shared_from_this()` handles. Any `VALUE_ERROR` encountered → print `get_num()` + `"\n"`, `exit(1)`.
+- [ ] **Step 3:** `make runtime` builds `build/libpseudort.a`. Commit.
+
+### Task 4: Compiler skeleton + driver (milestone: arithmetic & print)
+
+**Files:**
+- Create: `src/compiler.h`, `src/compiler.cpp` (class `Compiler`: `bool compile(const NodeList& ast, llvm::Module&)`, error list with positions)
+- Create: `src/pseudoc.cpp` (driver: args, expand_imports, lex/parse with run()-style error printing, codegen, verify, O2 PassBuilder, TargetMachine object emission, link via `c++`)
+- Modify: `Makefile` (`compiler` target via `llvm-config`, default `/opt/homebrew/opt/llvm/bin/llvm-config` fallback; link `-lLLVM` from `--libdir` with rpath)
+
+- [ ] **Step 1:** Codegen for: ValueNode literals, VarAccess/VarAssign, BinOp/UnaryOp (`rt_bin_op` with op codes), AlgorithmCall (callee codegen + `rt_call`), statement sequencing in `main` (`rt_init` first, `ret i32 0` last). Unsupported node types → recorded compile error.
+- [ ] **Step 2:** Driver `--emit-llvm` and `-o`; runtime archive lookup (`--runtime-lib`, `$PSEUDO_RT_LIB`, `<exe dir>/build/libpseudort.a`).
+- [ ] **Step 3:** `make compiler`; `echo 'print("hi", 1 + 2 * 3)' > /tmp/t.ps && ./pseudoc /tmp/t.ps -o /tmp/t && /tmp/t` matches `./pseudo /tmp/t.ps`. Commit.
+
+### Task 5: Control flow
+
+**Files:**
+- Modify: `src/compiler.cpp`
+
+- [ ] **Step 1:** `if` (yields Int 0 when untaken, propagates last-statement value), `for` (assign → step default/check → end; latch keeps previous `i` slot per visit_for; per-iteration `rt_frame_mark`/`rt_frame_release`), `while`, `repeat`, `break`/`continue` (branch + release to loop mark), nested loops via a loop-context stack.
+- [ ] **Step 2:** Differential run of `test/compiler/control_flow.ps`, `test/test_repeat.ps` — PASS. Commit.
+
+### Task 6: Functions and return
+
+**Files:**
+- Modify: `src/compiler.cpp`
+
+- [ ] **Step 1:** AlgorithmDef → new LLVM function compiled with its own builder state (body statements; implicit result = last statement value; `ReturnNode` → `rt_keep` + `ret`); definition site emits `rt_define_algo` with arg-name global strings. Same handling when defs appear inside other bodies.
+- [ ] **Step 2:** Differential run of `test/compiler/functions.ps`, `test/test_fib.ps` — PASS. Commit.
+
+### Task 7: Arrays, hash tables, strings, member calls
+
+**Files:**
+- Modify: `src/compiler.cpp`
+
+- [ ] **Step 1:** ArrayNode literal, ArrayAccess (`rt_index`), ArrayAssign (`rt_index_assign`, including hash-table set; member assignment on non-instances reports the interpreter's error string at runtime), MemberAccess (`rt_member_access` → BoundMethodValue path; method calls flow through existing `rt_call` fallback).
+- [ ] **Step 2:** Differential run of `test/compiler/collections.ps`, `test/test_array_methods.ps`, `test/test_string_index.ps` — PASS. Commit.
+
+### Task 8: Struct rejection, error fixtures, full suite
+
+**Files:**
+- Modify: `src/compiler.cpp` (NODE_STRUCTDEF → "compile error: Struct is not supported by the compiler yet" with location; same for instance member assignment when detectable)
+- Modify: `Makefile` (`test-compiler` runs harness)
+
+- [ ] **Step 1:** `bash test/compiler_tests.sh` — ALL PASS (including struct rejection and runtime error fixtures).
+- [ ] **Step 2:** `make test` still green; `ci/clang-format-check.sh` clean (format new files).
+- [ ] **Step 3:** Update README (compile section). Commit.
+
+## Self-review notes
+
+- Spec coverage: every spec section maps to a task (tests→1, intrusive changes→2, runtime→3, driver/build→4, codegen semantics→4–7, struct rejection→8, README/CI→8).
+- Types consistent: ABI defined once in Task 3 and used in 4–7.
+- `rt_keep`'s frame semantics are decided in Task 3 (`re-register in caller frame`), used by Task 6 return handling.

From 1f63f9393b7cb33796668ad9bb6bb119593f9944 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:16:24 +0800
Subject: [PATCH 03/12] test: differential compiler test harness and fixtures

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 Makefile                      |   5 ++-
 test/compiler/basics.ps       | Bin 0 -> 381 bytes
 test/compiler/collections.ps  | Bin 0 -> 681 bytes
 test/compiler/control_flow.ps | Bin 0 -> 777 bytes
 test/compiler/errors.ps       | Bin 0 -> 67 bytes
 test/compiler/functions.ps    | Bin 0 -> 597 bytes
 test/compiler_tests.sh        |  69 ++++++++++++++++++++++++++++++++++
 7 files changed, 73 insertions(+), 1 deletion(-)
 create mode 100644 test/compiler/basics.ps
 create mode 100644 test/compiler/collections.ps
 create mode 100644 test/compiler/control_flow.ps
 create mode 100644 test/compiler/errors.ps
 create mode 100644 test/compiler/functions.ps
 create mode 100755 test/compiler_tests.sh

diff --git a/Makefile b/Makefile
index 15b3eb5..acd30df 100644
--- a/Makefile
+++ b/Makefile
@@ -66,7 +66,10 @@ test: $(TEST_TARGET)
 coverage: test
 	gcov -r -o $(BUILD_COV_DIR) $(filter-out src/shell.cpp, $(SRCS))
 
-.PHONY: clean all test coverage lsp
+test-compiler: $(TARGET)
+	bash test/compiler_tests.sh
+
+.PHONY: clean all test coverage lsp test-compiler
 lsp: $(LSP_TARGET)
 
 clean:
diff --git a/test/compiler/basics.ps b/test/compiler/basics.ps
new file mode 100644
index 0000000000000000000000000000000000000000..582ea99a9ec6c18da3e2c91afeea092b9671e2c3
GIT binary patch
literal 381
zcmYL_@e0Bq5XS%aDZYdtOV_kU1*=C19JLC@j7{kEyPK{M{du4F>3JTt!9g^Pop=wg
zKCV1AXf!-b!a8A_uuQn3QKDs=E2?a4$!IlNtl=12ltrasS|vu#l+SzD1t}s2BPB~3
zw0^?S-DJKbs$Usr9Jq`{W{n+(mxMa2motvD#lrVDE+K77jS^vCVIswSh{&*iR}D8g
z9q0{ql=GSK8XKC%_*vo>$-R>*|F#RB1Y1<3OdlU3wehh!oj5}-<ZN`f!qVeRYK#(J
DHO5;i

literal 0
HcmV?d00001

diff --git a/test/compiler/collections.ps b/test/compiler/collections.ps
new file mode 100644
index 0000000000000000000000000000000000000000..341f18ed45686af8b07185c40470b3ae1162b9d4
GIT binary patch
literal 681
zcmYjO!H&Wp5WVvi6HXA>#<s@9#1GgH*jwWPEiOb`8bCL@#(&=dN|gf{m^W|Uyphhq
z{sSJhfJQ+3B$G2^VA45G@T#Vp*KG3^)3doN%3rw3n?J?4fCxXz(}nT3Y*!y(6;oYP
zg7%Q;;s<ta)-Niov(u#d_@A2Fi50G#$z5{CEXs^txxi5WZdb5a%ZXEiy}!8flQji1
zrxRgjaw_p|3nD5goyd?}N;W+OJX!&pXEAHQA#oZ31Kt>Ol7c+nrpz~RLUd&LlwN<y
z;}uOKx}$bfG&xb@E7#EQW9e*5K?sQ1qD?Q#^1gI+vSW~F21|svj`y#@cyGpUiks2Z
z>_o<uE(;&_yUcoua$Q~2ua9dbJ`O-9uWtRK&@Z)Fi_bgv-4^8r8{{<>t;yLsFfptl
VSSVG{TLO3%U=CJL&(hMHlYe~q&)5I}

literal 0
HcmV?d00001

diff --git a/test/compiler/control_flow.ps b/test/compiler/control_flow.ps
new file mode 100644
index 0000000000000000000000000000000000000000..387ff92431c09074de9137ad7e270505545a3123
GIT binary patch
literal 777
zcmZva&2GXl5QOh}iV;$!7K%ims2AW}Tv&=#V<X3DdHn8=2_VSH_Re~~o!DVDMZ0YL
z9u6zCGn50x2K=3}kL7jL9bE{cw}wJTsIvK^>_|J`AFJ-RKe+r&d~OySws>rg^h;SZ
zB^4J0Y1ZshhF3b2Bw)Lw*A5a}OyC<M)ji*FZDb?vL|5p9>HKnmsXZ&%HFnS3c)se!
z1ADw+jx}F2L?iKRQ!GCAq);m3**@+yUzyyG3I;1%T&Z<0>FB7<-@yltS%1Y9LTVmk
zEb6ENzfFBC25(KRGFI-PYKsZl3#T1y)>uAcwQy9!9?_sOoyZmFE@FaDu(c0-u)$(h
znIh{Y`qUT7+9&BRE<x&FiSb!U(v$$Ty5_9!a(>8K4h++*#_~8gP-$m|vv@CWUcnuP
QR?jTwXIR0{@8CTD0W)pQOaK4?

literal 0
HcmV?d00001

diff --git a/test/compiler/errors.ps b/test/compiler/errors.ps
new file mode 100644
index 0000000000000000000000000000000000000000..0728c64bb7b2cc8ca0c80049adacf50692b12b5d
GIT binary patch
literal 67
zcmYc+DpIh~Rj4-9Q83a`Fs|h)D9X$$(MT*RiZ+bZMCKX5xk{yZMX8C&8Hq_bsY;q$
E0JRbo0RR91

literal 0
HcmV?d00001

diff --git a/test/compiler/functions.ps b/test/compiler/functions.ps
new file mode 100644
index 0000000000000000000000000000000000000000..3c2147cc710a466d444222a45ea8e5ca58cde597
GIT binary patch
literal 597
zcmZ8f%Z`H}6y5U`C$4a66LBV)WYRABB?c8n5(@@tr~Ui6Ry0yq=5o)2bGQt@&YRF*
zA-j&t0!{wIK%ZCP<}D-+Xc!y4v4PJkRe{eu-wiVDTvi}!q|fMpT{cE7+rVw)Ga44B
zGXz4f>`E{8S{5HzFgQXG)uQ?ui8AFL<P_>D$e^x@oIRq-gD9#M__kAtl)~MD^7YiZ
zQStQBz3Dpgcz|Fm{-2Kc646isOl~a4ad_6@&$No`0;{W-rRJK9CIDkweow{ki*8JO
zM@YK`-g8jW56>-R?K}*~E2Zpcw?yY&3D1pE0|sYmVJ={s?z%P<9%0ITC*>OEBJ@4m
XpPvEMvpCG8rWn!6VSw`9(Ia60%BQcC

literal 0
HcmV?d00001

diff --git a/test/compiler_tests.sh b/test/compiler_tests.sh
new file mode 100755
index 0000000..bc89477
--- /dev/null
+++ b/test/compiler_tests.sh
@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# Differential tests: compiled binaries must produce the same stdout as the
+# interpreter. Run from the repository root after `make` and `make compiler`.
+set -u
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+PSEUDO="$ROOT/pseudo"
+PSEUDOC="$ROOT/pseudoc"
+WORKDIR="$(mktemp -d)"
+trap 'rm -rf "$WORKDIR"' EXIT
+
+if [[ ! -x "$PSEUDO" ]]; then
+    echo "missing $PSEUDO (run make first)" >&2
+    exit 1
+fi
+if [[ ! -x "$PSEUDOC" ]]; then
+    echo "missing $PSEUDOC (run make compiler first)" >&2
+    exit 1
+fi
+
+FILES=(
+    "$ROOT"/test/compiler/*.ps
+    "$ROOT/test/test_fib.ps"
+    "$ROOT/test/test_repeat.ps"
+    "$ROOT/test/test_array_methods.ps"
+    "$ROOT/test/test_string_index.ps"
+)
+
+failures=0
+for src in "${FILES[@]}"; do
+    name="$(basename "$src" .ps)"
+    expected="$WORKDIR/$name.expected"
+    actual="$WORKDIR/$name.actual"
+    bin="$WORKDIR/$name.bin"
+
+    "$PSEUDO" "$src" > "$expected" 2>&1
+    if ! "$PSEUDOC" "$src" -o "$bin" > "$WORKDIR/$name.compile" 2>&1; then
+        echo "FAIL $name: compilation failed"
+        sed 's/^/    /' "$WORKDIR/$name.compile"
+        failures=$((failures + 1))
+        continue
+    fi
+    "$bin" > "$actual" 2>&1
+    if ! diff -u "$expected" "$actual" > "$WORKDIR/$name.diff"; then
+        echo "FAIL $name: output mismatch"
+        sed 's/^/    /' "$WORKDIR/$name.diff"
+        failures=$((failures + 1))
+    else
+        echo "PASS $name"
+    fi
+done
+
+# Struct programs must be rejected at compile time with a clear message.
+if "$PSEUDOC" "$ROOT/test/test_struct.ps" -o "$WORKDIR/struct.bin" > "$WORKDIR/struct.out" 2>&1; then
+    echo "FAIL struct-rejection: expected compile error"
+    failures=$((failures + 1))
+elif ! grep -q "Struct is not supported" "$WORKDIR/struct.out"; then
+    echo "FAIL struct-rejection: wrong error message"
+    sed 's/^/    /' "$WORKDIR/struct.out"
+    failures=$((failures + 1))
+else
+    echo "PASS struct-rejection"
+fi
+
+if [[ $failures -ne 0 ]]; then
+    echo "$failures test(s) failed"
+    exit 1
+fi
+echo "all compiler tests passed"

From 1822b0e1d9aa6b3e5ecfc4c0cdb06a42a81c8803 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:18:09 +0800
Subject: [PATCH 04/12] refactor: expose import expansion, add PrecomputedNode
 and shared_from_this on Value

Groundwork for the LLVM compiler runtime: compiled code needs to recover
shared_ptr ownership from raw Value pointers, reuse builtin/method execute
paths with pre-evaluated arguments, and expand imports outside run().

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/imports.h       | 23 +++++++++++++++++++++++
 src/interpreter.cpp |  3 +++
 src/node.h          |  1 +
 src/pseudo.cpp      | 10 +++-------
 src/value.h         | 15 ++++++++++++++-
 5 files changed, 44 insertions(+), 8 deletions(-)
 create mode 100644 src/imports.h

diff --git a/src/imports.h b/src/imports.h
new file mode 100644
index 0000000..2f109d4
--- /dev/null
+++ b/src/imports.h
@@ -0,0 +1,23 @@
+/// --------------------
+/// Import expansion
+/// --------------------
+
+#ifndef IMPORTS_H
+#define IMPORTS_H
+
+#include <set>
+#include <string>
+
+struct ImportState {
+    std::set<std::string> loaded;
+    std::set<std::string> loading;
+};
+
+// Recursively replaces `import` lines in `text` with the imported file
+// contents. Returns false and fills `error` on unresolved, unreadable, or
+// circular imports.
+bool expand_imports(const std::string &file_name, const std::string &text,
+                    ImportState &state, std::string &expanded,
+                    std::string &error);
+
+#endif
diff --git a/src/interpreter.cpp b/src/interpreter.cpp
index 47e39bb..c2589e4 100644
--- a/src/interpreter.cpp
+++ b/src/interpreter.cpp
@@ -106,6 +106,9 @@ std::shared_ptr<Value> Interpreter::visit(std::shared_ptr<Node> node) {
     if(node->get_type() == NODE_CONTINUE) {
         return std::make_shared<ControlValue>(VALUE_CONTINUE);
     }
+    if(node->get_type() == NODE_PRECOMPUTED) {
+        return dynamic_cast<PrecomputedNode*>(node.get())->get_value();
+    }
     return std::make_shared<ErrorValue>(VALUE_ERROR, "Fail to get result\n");
 }
 
diff --git a/src/node.h b/src/node.h
index 11888d0..752b129 100644
--- a/src/node.h
+++ b/src/node.h
@@ -33,6 +33,7 @@ const std::string NODE_STRUCTDEF("STRUCTDEF");
 const std::string NODE_RETURN("RETURN");
 const std::string NODE_BREAK("BREAK");
 const std::string NODE_CONTINUE("CONTINUE");
+const std::string NODE_PRECOMPUTED("PRECOMPUTED");
 const std::string TAB{"    "};
 
 class Node {
diff --git a/src/pseudo.cpp b/src/pseudo.cpp
index dbf7ab0..7e64ed8 100644
--- a/src/pseudo.cpp
+++ b/src/pseudo.cpp
@@ -1,4 +1,5 @@
 #include "pseudo.h"
+#include "imports.h"
 #include "color.h"
 #include "interpreter.h"
 #include "node.h"
@@ -1206,11 +1207,6 @@ std::shared_ptr<Value> StructValue::execute(const NodeList& args,
 
 namespace {
 
-struct ImportState {
-  std::set<std::string> loaded;
-  std::set<std::string> loading;
-};
-
 std::string trim(const std::string &str) {
   size_t begin = 0;
   while (begin < str.size() &&
@@ -1304,6 +1300,8 @@ bool resolve_import(const std::string &target,
   return false;
 }
 
+} // namespace
+
 bool expand_imports(const std::string &file_name, const std::string &text,
                     ImportState &state, std::string &expanded,
                     std::string &error) {
@@ -1358,8 +1356,6 @@ bool expand_imports(const std::string &file_name, const std::string &text,
   return true;
 }
 
-} // namespace
-
 std::string run(std::string file_name, std::string text,
                 SymbolTable &global_symbol_table) {
   ImportState import_state;
diff --git a/src/value.h b/src/value.h
index 4a786a6..feb7d6b 100644
--- a/src/value.h
+++ b/src/value.h
@@ -36,7 +36,7 @@ const std::map<char, char> REVERSE_ESCAPE_CHAR {
 
 class SymbolTable;
 class Interpreter;
-class Value {
+class Value: public std::enable_shared_from_this<Value> {
 public:
     Value(const std::string& _type = VALUE_NONE)
         : type(_type) {}
@@ -264,6 +264,19 @@ class ControlValue : public Value {
         : Value(_type) {}
 };
 
+// Wraps an already-evaluated value as an AST node so compiled code can reuse
+// interpreter execution paths that expect argument nodes (builtins, methods).
+class PrecomputedNode: public Node {
+public:
+    explicit PrecomputedNode(std::shared_ptr<Value> _value)
+        : value(_value) {}
+    std::string get_node() override { return "PRECOMPUTED";}
+    std::string get_type() override { return NODE_PRECOMPUTED;}
+    std::shared_ptr<Value> get_value() { return value;}
+protected:
+    std::shared_ptr<Value> value;
+};
+
 template class TypedValue<double>;
 template class TypedValue<int64_t>;
 template class TypedValue<std::string>;

From 4a7f3f90e444442e52faf742cfe4312b6984c8d8 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:22:55 +0800
Subject: [PATCH 05/12] feat: runtime library for compiled programs

extern "C" rt_* shims over the existing Value/SymbolTable machinery, with
arena-frame lifetime tracking and a CompiledAlgoValue that bridges native
function pointers into the interpreter's call protocol. Runtime errors print
the interpreter's top-level message and exit(1).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 Makefile        |  11 +-
 src/runtime.cpp | 307 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/runtime.h   |  85 ++++++++++++++
 3 files changed, 402 insertions(+), 1 deletion(-)
 create mode 100644 src/runtime.cpp
 create mode 100644 src/runtime.h

diff --git a/Makefile b/Makefile
index acd30df..48a3eac 100644
--- a/Makefile
+++ b/Makefile
@@ -46,6 +46,15 @@ $(BUILD_COV_DIR)/%.o: src/%.cpp $(HEADERS) | $(BUILD_COV_DIR)
 run : $(TARGET)
 	./shell
 
+# Runtime library for compiled programs (interpreter core + rt_* shims)
+RT_LIB = $(BUILD_DIR)/libpseudort.a
+RT_OBJS = $(filter-out $(BUILD_DIR)/shell.o,$(OBJS)) $(BUILD_DIR)/runtime.o
+
+$(RT_LIB): $(RT_OBJS)
+	ar rcs $@ $(RT_OBJS)
+
+runtime: $(BUILD_DIR) $(RT_LIB)
+
 # Google Test rules
 
 GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
@@ -69,7 +78,7 @@ coverage: test
 test-compiler: $(TARGET)
 	bash test/compiler_tests.sh
 
-.PHONY: clean all test coverage lsp test-compiler
+.PHONY: clean all test coverage lsp test-compiler runtime compiler
 lsp: $(LSP_TARGET)
 
 clean:
diff --git a/src/runtime.cpp b/src/runtime.cpp
new file mode 100644
index 0000000..ed33fce
--- /dev/null
+++ b/src/runtime.cpp
@@ -0,0 +1,307 @@
+/// --------------------
+/// Compiled-program runtime
+/// --------------------
+
+#include "runtime.h"
+#include "color.h"
+#include "interpreter.h"
+#include "node.h"
+#include "symboltable.h"
+#include "value.h"
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace {
+
+// Arena frames keep every runtime-created value alive until its frame is
+// released; survivors are owned by symbol tables and containers.
+std::vector<std::vector<std::shared_ptr<Value>>> frames;
+// Scope stack: scopes.back() is the current symbol table; entry 0 holds the
+// globals. Parents follow the caller chain, like the interpreter.
+std::vector<std::unique_ptr<SymbolTable>> scopes;
+
+[[noreturn]] void rt_fail(const std::shared_ptr<Value> &err) {
+    std::cout << err->get_num() << "\n";
+    exit(1);
+}
+
+Value *track(std::shared_ptr<Value> value) {
+    if (value->get_type() == VALUE_ERROR) {
+        rt_fail(value);
+    }
+    frames.back().push_back(value);
+    return value.get();
+}
+
+std::shared_ptr<Value> ref(Value *v) { return v->shared_from_this(); }
+
+SymbolTable &current_scope() { return *scopes.back(); }
+
+class CompiledAlgoValue : public Value {
+public:
+    CompiledAlgoValue(const std::string &_algo_name, Value *(*_fn)(),
+                      std::vector<std::string> _arg_names)
+        : Value(VALUE_ALGO), fn(_fn), algo_name(_algo_name),
+          arg_names(std::move(_arg_names)) {}
+
+    std::string get_num() override { return algo_name; }
+    std::string repr() override { return algo_name; }
+
+    std::shared_ptr<Value> execute(const NodeList &args = {},
+                                   SymbolTable *parent = nullptr) override;
+
+    Value *(*fn)();
+    std::string algo_name;
+    std::vector<std::string> arg_names;
+};
+
+std::shared_ptr<Value> call_compiled(CompiledAlgoValue *algo,
+                                     const ValueList &args) {
+    if (args.size() < algo->arg_names.size()) {
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too few arguments" RESET);
+    }
+    if (args.size() > algo->arg_names.size()) {
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too many arguments" RESET);
+    }
+
+    int64_t mark = rt_frame_mark();
+    rt_frame_push();
+    scopes.push_back(std::make_unique<SymbolTable>(&current_scope()));
+    for (size_t i = 0; i < args.size(); ++i) {
+        scopes.back()->set(algo->arg_names[i], args[i]);
+    }
+    Value *result = algo->fn();
+    std::shared_ptr<Value> kept = ref(result);
+    scopes.pop_back();
+    rt_frame_release(mark);
+    return kept;
+}
+
+std::shared_ptr<Value> CompiledAlgoValue::execute(const NodeList &args,
+                                                  SymbolTable *parent) {
+    SymbolTable sym(parent);
+    Interpreter interpreter(sym);
+    ValueList evaluated;
+    evaluated.reserve(args.size());
+    for (const auto &arg : args) {
+        std::shared_ptr<Value> v = interpreter.visit(arg);
+        if (v->get_type() == VALUE_ERROR) {
+            return v;
+        }
+        evaluated.push_back(v);
+    }
+    return call_compiled(this, evaluated);
+}
+
+} // namespace
+
+extern "C" {
+
+void rt_init() {
+    frames.emplace_back();
+    scopes.push_back(std::make_unique<SymbolTable>());
+}
+
+Value *rt_make_int(int64_t v) {
+    return track(std::make_shared<TypedValue<int64_t>>(VALUE_INT, v));
+}
+
+Value *rt_make_float(double v) {
+    return track(std::make_shared<TypedValue<double>>(VALUE_FLOAT, v));
+}
+
+Value *rt_make_string(const char *s) {
+    return track(
+        std::make_shared<TypedValue<std::string>>(VALUE_STRING, std::string(s)));
+}
+
+Value *rt_make_none() { return track(std::make_shared<Value>()); }
+
+Value *rt_array_new() {
+    return track(std::make_shared<ArrayValue>(ValueList(0)));
+}
+
+void rt_array_push(Value *arr, Value *v) {
+    dynamic_cast<ArrayValue *>(arr)->push_back(ref(v));
+}
+
+Value *rt_get_var(const char *name) {
+    return track(current_scope().get(name));
+}
+
+Value *rt_set_var(const char *name, Value *v) {
+    current_scope().set(name, ref(v));
+    return track(current_scope().get(name));
+}
+
+Value *rt_bin_op(int64_t op, Value *a, Value *b) {
+    std::shared_ptr<Value> lhs = ref(a), rhs = ref(b);
+    switch (op) {
+    case RT_OP_ADD: return track(lhs + rhs);
+    case RT_OP_SUB: return track(lhs - rhs);
+    case RT_OP_MUL: return track(lhs * rhs);
+    case RT_OP_DIV: return track(lhs / rhs);
+    case RT_OP_MOD: return track(lhs % rhs);
+    case RT_OP_POW: return track(pow(lhs, rhs));
+    case RT_OP_EQUAL: return track(lhs == rhs);
+    case RT_OP_NEQ: return track(lhs != rhs);
+    case RT_OP_LESS: return track(lhs < rhs);
+    case RT_OP_GREATER: return track(lhs > rhs);
+    case RT_OP_LEQ: return track(lhs <= rhs);
+    case RT_OP_GEQ: return track(lhs >= rhs);
+    default:
+        rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Not a binary op\n"));
+    }
+}
+
+Value *rt_unary_op(int64_t op, Value *a) {
+    std::shared_ptr<Value> operand = ref(a);
+    switch (op) {
+    case RT_OP_UPLUS: return track(operand);
+    case RT_OP_UNEG: return track(-operand);
+    case RT_OP_UNOT: return track(!operand);
+    default:
+        rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Not an unary op\n"));
+    }
+}
+
+Value *rt_bool(Value *v) { return rt_make_int(v->as_int() != 0); }
+
+int64_t rt_cond_eq1(Value *v) { return std::stoll(v->get_num()) == 1; }
+
+int64_t rt_as_int(Value *v) { return v->as_int(); }
+
+int64_t rt_for_cond(Value *i, Value *end, Value *step) {
+    if (step->as_double() > 0) {
+        if (i->get_type() == VALUE_FLOAT || end->get_type() == VALUE_FLOAT)
+            return i->as_double() <= end->as_double();
+        return i->as_int() <= end->as_int();
+    }
+    if (i->get_type() == VALUE_FLOAT || end->get_type() == VALUE_FLOAT)
+        return i->as_double() >= end->as_double();
+    return i->as_int() >= end->as_int();
+}
+
+void rt_for_step_check(Value *step) {
+    if (step->as_double() == 0) {
+        rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Infinite for loop\n"));
+    }
+}
+
+Value *rt_index(Value *obj, Value *idx) {
+    std::shared_ptr<Value> container = ref(obj), index = ref(idx);
+    if (container->get_type() == VALUE_STRING) {
+        std::string str = container->as_string();
+        int p = index->as_int();
+        if (1 <= p && p <= static_cast<int>(str.size())) {
+            return track(std::make_shared<TypedValue<std::string>>(
+                VALUE_STRING, std::string(1, str[p - 1])));
+        }
+        return track(std::make_shared<ErrorValue>(
+            VALUE_ERROR, "Index out of range, size: " + std::to_string(str.size()) +
+                             ", position: " + std::to_string(p)));
+    }
+    if (container->get_type() == VALUE_HASH_TABLE) {
+        return track(dynamic_cast<HashTableValue *>(container.get())->get(index));
+    }
+    if (container->get_type() != VALUE_ARRAY) {
+        return track(std::make_shared<ErrorValue>(
+            VALUE_ERROR,
+            "Access can only apply on array, find " + container->get_type() + "\n"));
+    }
+    return track(
+        dynamic_cast<ArrayValue *>(container.get())->operator[](index->as_int()));
+}
+
+Value *rt_index_assign(Value *obj, Value *idx, Value *v) {
+    std::shared_ptr<Value> container = ref(obj), index = ref(idx), value = ref(v);
+    if (container->get_type() == VALUE_HASH_TABLE) {
+        return track(
+            dynamic_cast<HashTableValue *>(container.get())->set(index, value));
+    }
+    if (container->get_type() != VALUE_ARRAY) {
+        return track(std::make_shared<ErrorValue>(
+            VALUE_ERROR, "Access can only apply on array or object member\n"));
+    }
+    // Matches visit_array_assign: an out-of-range index assigns into the
+    // array's error slot and is effectively ignored.
+    dynamic_cast<ArrayValue *>(container.get())->operator[](index->as_int()) =
+        value;
+    return track(value);
+}
+
+Value *rt_member_access(Value *obj, const char *name) {
+    std::shared_ptr<Value> object = ref(obj);
+    if (object->get_type() == VALUE_ARRAY || object->get_type() == VALUE_STRING ||
+        object->get_type() == VALUE_HASH_TABLE) {
+        return track(std::make_shared<BoundMethodValue>(object, name));
+    }
+    if (object->get_type() == VALUE_INSTANCE) {
+        return track(dynamic_cast<InstanceValue *>(object.get())
+                         ->get_member(name, object));
+    }
+    return track(std::make_shared<ErrorValue>(
+        VALUE_ERROR,
+        object->get_num() + " has no member " + std::string(name) + "\n"));
+}
+
+Value *rt_member_assign(Value *obj, const char *name, Value *v) {
+    std::shared_ptr<Value> object = ref(obj), value = ref(v);
+    if (object->get_type() == VALUE_INSTANCE) {
+        dynamic_cast<InstanceValue *>(object.get())->set_member(name, value);
+        return track(value);
+    }
+    return track(std::make_shared<ErrorValue>(
+        VALUE_ERROR, "Assignment to member only supported for Struct Instances\n"));
+}
+
+void rt_define_algo(const char *name, Value *(*fn)(),
+                    const char *const *arg_names, int64_t nargs) {
+    std::vector<std::string> names;
+    names.reserve(nargs);
+    for (int64_t i = 0; i < nargs; ++i) {
+        names.emplace_back(arg_names[i]);
+    }
+    std::shared_ptr<Value> algo =
+        std::make_shared<CompiledAlgoValue>(name, fn, std::move(names));
+    current_scope().set(name, algo);
+    track(algo);
+}
+
+Value *rt_call(Value *callee, Value **argv, int64_t argc) {
+    ValueList args;
+    args.reserve(argc);
+    for (int64_t i = 0; i < argc; ++i) {
+        args.push_back(ref(argv[i]));
+    }
+
+    if (auto *compiled = dynamic_cast<CompiledAlgoValue *>(callee)) {
+        return track(call_compiled(compiled, args));
+    }
+
+    // Builtins, bound methods, and other interpreter-executed callees: hand
+    // over the already-evaluated arguments as precomputed AST nodes.
+    NodeList arg_nodes;
+    arg_nodes.reserve(argc);
+    for (const auto &arg : args) {
+        arg_nodes.push_back(std::make_shared<PrecomputedNode>(arg));
+    }
+    return track(callee->execute(arg_nodes, &current_scope()));
+}
+
+int64_t rt_frame_mark() { return static_cast<int64_t>(frames.size()); }
+
+void rt_frame_push() { frames.emplace_back(); }
+
+void rt_frame_release(int64_t mark) {
+    while (static_cast<int64_t>(frames.size()) > mark) {
+        frames.pop_back();
+    }
+}
+
+} // extern "C"
diff --git a/src/runtime.h b/src/runtime.h
new file mode 100644
index 0000000..58c92ee
--- /dev/null
+++ b/src/runtime.h
@@ -0,0 +1,85 @@
+/// --------------------
+/// Compiled-program runtime
+/// --------------------
+///
+/// extern "C" entry points called by code generated by the LLVM compiler
+/// (src/compiler.cpp). All Value* parameters and results are raw pointers
+/// whose ownership is tracked by an arena frame stack inside the runtime;
+/// anything that must outlive a frame (variables, container elements) is
+/// kept alive by the SymbolTable / container shared_ptrs.
+///
+/// Any runtime error (a VALUE_ERROR result) prints the same message the
+/// interpreter prints at top level and exits with status 1.
+
+#ifndef RUNTIME_H
+#define RUNTIME_H
+
+#include <cstdint>
+
+class Value;
+
+// Operator codes shared between the compiler and the runtime.
+enum RtBinOpCode : int64_t {
+    RT_OP_ADD = 0,
+    RT_OP_SUB,
+    RT_OP_MUL,
+    RT_OP_DIV,
+    RT_OP_MOD,
+    RT_OP_POW,
+    RT_OP_EQUAL,
+    RT_OP_NEQ,
+    RT_OP_LESS,
+    RT_OP_GREATER,
+    RT_OP_LEQ,
+    RT_OP_GEQ,
+};
+
+enum RtUnaryOpCode : int64_t {
+    RT_OP_UPLUS = 0,
+    RT_OP_UNEG,
+    RT_OP_UNOT,
+};
+
+extern "C" {
+
+void rt_init();
+
+Value *rt_make_int(int64_t v);
+Value *rt_make_float(double v);
+Value *rt_make_string(const char *s);
+Value *rt_make_none();
+Value *rt_array_new();
+void rt_array_push(Value *arr, Value *v);
+
+Value *rt_get_var(const char *name);
+Value *rt_set_var(const char *name, Value *v);
+
+Value *rt_bin_op(int64_t op, Value *a, Value *b);
+Value *rt_unary_op(int64_t op, Value *a);
+// Int 0/1 value from as_int() != 0 (used by short-circuit and/or).
+Value *rt_bool(Value *v);
+
+// stoll(get_num()) == 1, the interpreter's `if` condition.
+int64_t rt_cond_eq1(Value *v);
+// as_int(), the interpreter's `while` / `repeat` condition.
+int64_t rt_as_int(Value *v);
+// Float-aware inclusive bound check matching Interpreter::visit_for.
+int64_t rt_for_cond(Value *i, Value *end, Value *step);
+// Errors out (like the interpreter) when step == 0.
+void rt_for_step_check(Value *step);
+
+Value *rt_index(Value *obj, Value *idx);
+Value *rt_index_assign(Value *obj, Value *idx, Value *v);
+Value *rt_member_access(Value *obj, const char *name);
+Value *rt_member_assign(Value *obj, const char *name, Value *v);
+
+void rt_define_algo(const char *name, Value *(*fn)(),
+                    const char *const *arg_names, int64_t nargs);
+Value *rt_call(Value *callee, Value **argv, int64_t argc);
+
+int64_t rt_frame_mark();
+void rt_frame_push();
+void rt_frame_release(int64_t mark);
+}
+
+#endif

From 52125d4f8594a566817ffa39e94461d5f9e0f027 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:33:45 +0800
Subject: [PATCH 06/12] feat: LLVM AOT compiler and pseudoc driver

Lowers the AST to LLVM IR with all operations dispatched to the rt_* runtime,
optimizes at O2, emits a native object file, and links it against
libpseudort.a. Loops get per-iteration arena frames; for-loops keep the
latest loop variable alive in a dedicated frame.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 Makefile         |  23 +-
 src/compiler.cpp | 697 +++++++++++++++++++++++++++++++++++++++++++++++
 src/compiler.h   |  25 ++
 src/pseudoc.cpp  | 267 ++++++++++++++++++
 src/runtime.cpp  |  12 +-
 src/runtime.h    |   7 +-
 6 files changed, 1025 insertions(+), 6 deletions(-)
 create mode 100644 src/compiler.cpp
 create mode 100644 src/compiler.h
 create mode 100644 src/pseudoc.cpp

diff --git a/Makefile b/Makefile
index 48a3eac..6c497c2 100644
--- a/Makefile
+++ b/Makefile
@@ -47,14 +47,35 @@ run : $(TARGET)
 	./shell
 
 # Runtime library for compiled programs (interpreter core + rt_* shims)
+# Prefer the system ar: GNU binutils ar produces archives Apple's ld rejects.
+AR := $(shell test -x /usr/bin/ar && echo /usr/bin/ar || echo ar)
 RT_LIB = $(BUILD_DIR)/libpseudort.a
 RT_OBJS = $(filter-out $(BUILD_DIR)/shell.o,$(OBJS)) $(BUILD_DIR)/runtime.o
 
 $(RT_LIB): $(RT_OBJS)
-	ar rcs $@ $(RT_OBJS)
+	$(AR) rcs $@ $(RT_OBJS)
 
 runtime: $(BUILD_DIR) $(RT_LIB)
 
+# LLVM AOT compiler (optional; requires LLVM, e.g. `brew install llvm`)
+LLVM_CONFIG ?= $(shell command -v llvm-config 2>/dev/null || echo /opt/homebrew/opt/llvm/bin/llvm-config)
+LLVM_INCLUDEDIR = $(shell $(LLVM_CONFIG) --includedir)
+LLVM_LIBDIR = $(shell $(LLVM_CONFIG) --libdir)
+LLVM_COMPILE_FLAGS = -I$(LLVM_INCLUDEDIR) -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+PSEUDOC_TARGET = pseudoc
+PSEUDOC_OBJS = $(filter-out $(BUILD_DIR)/shell.o,$(OBJS)) $(BUILD_DIR)/compiler.o $(BUILD_DIR)/pseudoc.o
+
+$(BUILD_DIR)/compiler.o: src/compiler.cpp $(HEADERS) | $(BUILD_DIR)
+	$(CC) -c $(CPPFLAGS) $(LLVM_COMPILE_FLAGS) src/compiler.cpp -o $@
+
+$(BUILD_DIR)/pseudoc.o: src/pseudoc.cpp $(HEADERS) | $(BUILD_DIR)
+	$(CC) -c $(CPPFLAGS) $(LLVM_COMPILE_FLAGS) src/pseudoc.cpp -o $@
+
+$(PSEUDOC_TARGET): $(BUILD_DIR) $(PSEUDOC_OBJS) $(RT_LIB)
+	$(CC) $(CPPFLAGS) $(PSEUDOC_OBJS) -L$(LLVM_LIBDIR) -lLLVM -Wl,-rpath,$(LLVM_LIBDIR) -o $(PSEUDOC_TARGET)
+
+compiler: $(PSEUDOC_TARGET) runtime
+
 # Google Test rules
 
 GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
diff --git a/src/compiler.cpp b/src/compiler.cpp
new file mode 100644
index 0000000..6d774f9
--- /dev/null
+++ b/src/compiler.cpp
@@ -0,0 +1,697 @@
+/// --------------------
+/// LLVM AOT compiler
+/// --------------------
+///
+/// Lowers the AST to LLVM IR. Every language operation becomes a call into
+/// the runtime (src/runtime.h); control flow becomes real basic blocks. The
+/// emitted code mirrors Interpreter::visit_* semantics; see
+/// docs/superpowers/specs/2026-06-10-llvm-compiler-design.md.
+
+#include "compiler.h"
+#include "node.h"
+#include "runtime.h"
+#include "token.h"
+
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/GlobalVariable.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/Module.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace {
+
+class CodeGen {
+public:
+    CodeGen(llvm::Module &_module, std::vector<std::string> &_errors)
+        : module(_module), ctx(_module.getContext()), builder(ctx),
+          errors(_errors) {
+        ptr_ty = builder.getPtrTy();
+        i64_ty = builder.getInt64Ty();
+        f64_ty = builder.getDoubleTy();
+    }
+
+    bool run(const NodeList &ast) {
+        llvm::Function *main_fn = llvm::Function::Create(
+            llvm::FunctionType::get(builder.getInt32Ty(), false),
+            llvm::Function::ExternalLinkage, "main", module);
+        llvm::BasicBlock *entry = llvm::BasicBlock::Create(ctx, "entry", main_fn);
+        builder.SetInsertPoint(entry);
+        builder.CreateCall(get_rt("rt_init", builder.getVoidTy(), {}));
+
+        for (const auto &node : ast) {
+            if (gen(node) == nullptr && block_terminated()) {
+                break;
+            }
+        }
+        if (!block_terminated()) {
+            builder.CreateRet(builder.getInt32(0));
+        }
+        return errors.empty();
+    }
+
+private:
+    struct LoopContext {
+        llvm::BasicBlock *latch;
+        llvm::BasicBlock *exit;
+        llvm::Value *iter_mark;
+        // `while` re-pushes its iteration frame in the header, so `continue`
+        // must release first; `for`/`repeat` latches release it themselves.
+        bool release_on_continue;
+    };
+
+    llvm::Module &module;
+    llvm::LLVMContext &ctx;
+    llvm::IRBuilder<> builder;
+    std::vector<std::string> &errors;
+
+    llvm::PointerType *ptr_ty{nullptr};
+    llvm::Type *i64_ty{nullptr};
+    llvm::Type *f64_ty{nullptr};
+
+    std::vector<LoopContext> loops;
+    std::map<std::string, llvm::Value *> string_constants;
+    int algo_counter{0};
+
+    /// ---- helpers ----
+
+    llvm::FunctionCallee get_rt(const std::string &name, llvm::Type *ret,
+                                std::vector<llvm::Type *> args) {
+        return module.getOrInsertFunction(
+            name, llvm::FunctionType::get(ret, args, false));
+    }
+
+    bool block_terminated() {
+        return builder.GetInsertBlock()->getTerminator() != nullptr;
+    }
+
+    llvm::Value *cstring(const std::string &text) {
+        auto found = string_constants.find(text);
+        if (found != string_constants.end()) {
+            return found->second;
+        }
+        llvm::Value *global = builder.CreateGlobalString(text, "str");
+        string_constants[text] = global;
+        return global;
+    }
+
+    llvm::AllocaInst *entry_alloca(llvm::Type *type) {
+        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        llvm::IRBuilder<> tmp(&fn->getEntryBlock(), fn->getEntryBlock().begin());
+        return tmp.CreateAlloca(type);
+    }
+
+    void error(const std::string &message, const std::shared_ptr<Node> &node) {
+        std::string suffix;
+        std::shared_ptr<Token> tok = node ? node->get_tok() : nullptr;
+        if (tok) {
+            suffix = " (line " + std::to_string(tok->get_pos().line + 1) + ")";
+        }
+        errors.push_back(message + suffix);
+    }
+
+    llvm::Value *make_none() {
+        return builder.CreateCall(get_rt("rt_make_none", ptr_ty, {}));
+    }
+
+    llvm::Value *make_int(int64_t v) {
+        return builder.CreateCall(get_rt("rt_make_int", ptr_ty, {i64_ty}),
+                                  {builder.getInt64(v)});
+    }
+
+    llvm::Value *frame_mark() {
+        return builder.CreateCall(get_rt("rt_frame_mark", i64_ty, {}));
+    }
+
+    void frame_push() {
+        builder.CreateCall(get_rt("rt_frame_push", builder.getVoidTy(), {}));
+    }
+
+    void frame_release(llvm::Value *mark) {
+        builder.CreateCall(get_rt("rt_frame_release", builder.getVoidTy(), {i64_ty}),
+                           {mark});
+    }
+
+    /// ---- dispatch ----
+
+    // Emits code for one node. Returns the node's value (an LLVM `ptr` to a
+    // runtime Value) or nullptr when the node terminated the current block
+    // (break/continue/return) or reported a compile error.
+    llvm::Value *gen(const std::shared_ptr<Node> &node) {
+        const std::string type = node->get_type();
+        if (type == NODE_VALUE) return gen_literal(node);
+        if (type == NODE_VARACCESS) return gen_var_access(node);
+        if (type == NODE_VARASSIGN) return gen_var_assign(node);
+        if (type == NODE_BINOP) return gen_bin_op(node);
+        if (type == NODE_UNARYOP) return gen_unary_op(node);
+        if (type == NODE_IF) return gen_if(node);
+        if (type == NODE_FOR) return gen_for(node);
+        if (type == NODE_WHILE) return gen_while(node);
+        if (type == NODE_REPEAT) return gen_repeat(node);
+        if (type == NODE_ALGODEF) return gen_algo_def(node);
+        if (type == NODE_ALGOCALL) return gen_algo_call(node);
+        if (type == NODE_ARRAY) return gen_array(node);
+        if (type == NODE_ARRACCESS) return gen_array_access(node);
+        if (type == NODE_ARRASSIGN) return gen_array_assign(node);
+        if (type == NODE_MEMACCESS) return gen_member_access(node);
+        if (type == NODE_RETURN) return gen_return(node);
+        if (type == NODE_BREAK) return gen_loop_jump(node, true);
+        if (type == NODE_CONTINUE) return gen_loop_jump(node, false);
+        if (type == NODE_STRUCTDEF) {
+            error("compile error: Struct is not supported by the compiler yet",
+                  node);
+            return nullptr;
+        }
+        error("compile error: unsupported statement " + type, node);
+        return nullptr;
+    }
+
+    // Emits a statement sequence; returns the last statement's value, or
+    // nullptr when the sequence terminated the block (or errored).
+    llvm::Value *gen_statements(const NodeList &nodes) {
+        llvm::Value *last = nullptr;
+        for (const auto &node : nodes) {
+            last = gen(node);
+            if (last == nullptr) {
+                return nullptr;
+            }
+        }
+        return last;
+    }
+
+    /// ---- expressions ----
+
+    llvm::Value *gen_literal(const std::shared_ptr<Node> &node) {
+        std::shared_ptr<Token> tok = node->get_tok();
+        if (tok->get_type() == TOKEN_INT) {
+            return make_int(std::stoll(tok->get_value()));
+        }
+        if (tok->get_type() == TOKEN_FLOAT) {
+            return builder.CreateCall(
+                get_rt("rt_make_float", ptr_ty, {f64_ty}),
+                {llvm::ConstantFP::get(f64_ty, std::stod(tok->get_value()))});
+        }
+        if (tok->get_type() == TOKEN_STRING) {
+            return builder.CreateCall(get_rt("rt_make_string", ptr_ty, {ptr_ty}),
+                                      {cstring(tok->get_value())});
+        }
+        error("compile error: unsupported literal " + tok->get_type(), node);
+        return nullptr;
+    }
+
+    llvm::Value *gen_var_access(const std::shared_ptr<Node> &node) {
+        return builder.CreateCall(get_rt("rt_get_var", ptr_ty, {ptr_ty}),
+                                  {cstring(node->get_name())});
+    }
+
+    llvm::Value *gen_var_assign(const std::shared_ptr<Node> &node) {
+        llvm::Value *value = gen(node->get_child()[0]);
+        if (value == nullptr) {
+            return nullptr;
+        }
+        return builder.CreateCall(get_rt("rt_set_var", ptr_ty, {ptr_ty, ptr_ty}),
+                                  {cstring(node->get_name()), value});
+    }
+
+    llvm::Value *as_int(llvm::Value *value) {
+        return builder.CreateCall(get_rt("rt_as_int", i64_ty, {ptr_ty}), {value});
+    }
+
+    llvm::Value *gen_bin_op(const std::shared_ptr<Node> &node) {
+        std::shared_ptr<Token> op = node->get_tok();
+        if (op->get_type() == TOKEN_KEYWORD &&
+            (op->get_value() == "and" || op->get_value() == "or")) {
+            return gen_short_circuit(node, op->get_value() == "and");
+        }
+
+        static const std::map<std::string, int64_t> OP_CODES{
+            {TOKEN_ADD, RT_OP_ADD},     {TOKEN_SUB, RT_OP_SUB},
+            {TOKEN_MUL, RT_OP_MUL},     {TOKEN_DIV, RT_OP_DIV},
+            {TOKEN_MOD, RT_OP_MOD},     {TOKEN_POW, RT_OP_POW},
+            {TOKEN_EQUAL, RT_OP_EQUAL}, {TOKEN_NEQ, RT_OP_NEQ},
+            {TOKEN_LESS, RT_OP_LESS},   {TOKEN_GREATER, RT_OP_GREATER},
+            {TOKEN_LEQ, RT_OP_LEQ},     {TOKEN_GEQ, RT_OP_GEQ},
+        };
+        auto code = OP_CODES.find(op->get_type());
+        if (code == OP_CODES.end()) {
+            error("compile error: unsupported operator " + op->get_type(), node);
+            return nullptr;
+        }
+
+        NodeList child = node->get_child();
+        llvm::Value *lhs = gen(child[0]);
+        if (lhs == nullptr) return nullptr;
+        llvm::Value *rhs = gen(child[1]);
+        if (rhs == nullptr) return nullptr;
+        return builder.CreateCall(
+            get_rt("rt_bin_op", ptr_ty, {i64_ty, ptr_ty, ptr_ty}),
+            {builder.getInt64(code->second), lhs, rhs});
+    }
+
+    // Mirrors visit_bin_op's short-circuit `and` / `or`: the result is always
+    // an Int 0/1 derived from as_int().
+    llvm::Value *gen_short_circuit(const std::shared_ptr<Node> &node,
+                                   bool is_and) {
+        NodeList child = node->get_child();
+        llvm::Value *lhs = gen(child[0]);
+        if (lhs == nullptr) return nullptr;
+
+        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock *rhs_bb = llvm::BasicBlock::Create(ctx, "sc.rhs", fn);
+        llvm::BasicBlock *short_bb = llvm::BasicBlock::Create(ctx, "sc.short", fn);
+        llvm::BasicBlock *merge_bb = llvm::BasicBlock::Create(ctx, "sc.merge", fn);
+
+        llvm::Value *lhs_true =
+            builder.CreateICmpNE(as_int(lhs), builder.getInt64(0));
+        if (is_and) {
+            builder.CreateCondBr(lhs_true, rhs_bb, short_bb);
+        } else {
+            builder.CreateCondBr(lhs_true, short_bb, rhs_bb);
+        }
+
+        builder.SetInsertPoint(short_bb);
+        llvm::Value *short_value = make_int(is_and ? 0 : 1);
+        builder.CreateBr(merge_bb);
+
+        builder.SetInsertPoint(rhs_bb);
+        llvm::Value *rhs = gen(child[1]);
+        if (rhs == nullptr) return nullptr;
+        llvm::Value *rhs_value =
+            builder.CreateCall(get_rt("rt_bool", ptr_ty, {ptr_ty}), {rhs});
+        llvm::BasicBlock *rhs_end = builder.GetInsertBlock();
+        builder.CreateBr(merge_bb);
+
+        builder.SetInsertPoint(merge_bb);
+        llvm::PHINode *phi = builder.CreatePHI(ptr_ty, 2);
+        phi->addIncoming(short_value, short_bb);
+        phi->addIncoming(rhs_value, rhs_end);
+        return phi;
+    }
+
+    llvm::Value *gen_unary_op(const std::shared_ptr<Node> &node) {
+        std::shared_ptr<Token> op = node->get_tok();
+        int64_t code;
+        if (op->get_type() == TOKEN_ADD) {
+            code = RT_OP_UPLUS;
+        } else if (op->get_type() == TOKEN_SUB) {
+            code = RT_OP_UNEG;
+        } else if (op->get_type() == TOKEN_KEYWORD && op->get_value() == "not") {
+            code = RT_OP_UNOT;
+        } else {
+            error("compile error: unsupported unary operator " + op->get_type(),
+                  node);
+            return nullptr;
+        }
+        llvm::Value *operand = gen(node->get_child()[0]);
+        if (operand == nullptr) return nullptr;
+        return builder.CreateCall(get_rt("rt_unary_op", ptr_ty, {i64_ty, ptr_ty}),
+                                  {builder.getInt64(code), operand});
+    }
+
+    /// ---- control flow ----
+
+    llvm::Value *gen_if(const std::shared_ptr<Node> &node) {
+        IfNode *if_node = dynamic_cast<IfNode *>(node.get());
+        llvm::Value *cond = gen(if_node->get_condition());
+        if (cond == nullptr) return nullptr;
+        llvm::Value *taken = builder.CreateICmpNE(
+            builder.CreateCall(get_rt("rt_cond_eq1", i64_ty, {ptr_ty}), {cond}),
+            builder.getInt64(0));
+
+        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock *then_bb = llvm::BasicBlock::Create(ctx, "if.then", fn);
+        llvm::BasicBlock *else_bb = llvm::BasicBlock::Create(ctx, "if.else", fn);
+        llvm::BasicBlock *merge_bb = llvm::BasicBlock::Create(ctx, "if.merge", fn);
+        llvm::AllocaInst *slot = entry_alloca(ptr_ty);
+        builder.CreateCondBr(taken, then_bb, else_bb);
+
+        bool merge_reachable = false;
+        builder.SetInsertPoint(then_bb);
+        llvm::Value *then_value = gen_statements(if_node->get_expr());
+        if (!errors.empty()) return nullptr;
+        if (then_value != nullptr) {
+            builder.CreateStore(then_value, slot);
+        }
+        if (!block_terminated()) {
+            builder.CreateBr(merge_bb);
+            merge_reachable = true;
+        }
+
+        builder.SetInsertPoint(else_bb);
+        llvm::Value *else_value = if_node->get_else().empty()
+                                      ? make_int(0)
+                                      : gen_statements(if_node->get_else());
+        if (!errors.empty()) return nullptr;
+        if (else_value != nullptr) {
+            builder.CreateStore(else_value, slot);
+        }
+        if (!block_terminated()) {
+            builder.CreateBr(merge_bb);
+            merge_reachable = true;
+        }
+
+        if (!merge_reachable) {
+            merge_bb->eraseFromParent();
+            return nullptr;
+        }
+        builder.SetInsertPoint(merge_bb);
+        return builder.CreateLoad(ptr_ty, slot);
+    }
+
+    llvm::Value *gen_while(const std::shared_ptr<Node> &node) {
+        NodeList child = node->get_child();
+        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock *header = llvm::BasicBlock::Create(ctx, "while.cond", fn);
+        llvm::BasicBlock *body_bb = llvm::BasicBlock::Create(ctx, "while.body", fn);
+        llvm::BasicBlock *exit_bb = llvm::BasicBlock::Create(ctx, "while.exit", fn);
+
+        llvm::Value *mark = frame_mark();
+        builder.CreateBr(header);
+
+        // One arena frame per iteration covers the condition and the body.
+        builder.SetInsertPoint(header);
+        frame_push();
+        llvm::Value *cond = gen(child[0]);
+        if (cond == nullptr) return nullptr;
+        llvm::Value *enter = builder.CreateICmpEQ(as_int(cond), builder.getInt64(1));
+        builder.CreateCondBr(enter, body_bb, exit_bb);
+
+        builder.SetInsertPoint(body_bb);
+        loops.push_back({header, exit_bb, mark, true});
+        bool terminated = gen_body(NodeList(child.begin() + 1, child.end()));
+        loops.pop_back();
+        if (!errors.empty()) return nullptr;
+        if (!terminated) {
+            frame_release(mark);
+            builder.CreateBr(header);
+        }
+
+        builder.SetInsertPoint(exit_bb);
+        frame_release(mark);
+        return make_none();
+    }
+
+    llvm::Value *gen_repeat(const std::shared_ptr<Node> &node) {
+        NodeList child = node->get_child();
+        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock *body_bb = llvm::BasicBlock::Create(ctx, "repeat.body", fn);
+        llvm::BasicBlock *latch = llvm::BasicBlock::Create(ctx, "repeat.cond", fn);
+        llvm::BasicBlock *exit_bb = llvm::BasicBlock::Create(ctx, "repeat.exit", fn);
+
+        llvm::Value *mark = frame_mark();
+        builder.CreateBr(body_bb);
+
+        builder.SetInsertPoint(body_bb);
+        frame_push();
+        loops.push_back({latch, exit_bb, mark, false});
+        bool terminated = gen_body(NodeList(child.begin() + 1, child.end()));
+        loops.pop_back();
+        if (!errors.empty()) return nullptr;
+        if (!terminated) {
+            builder.CreateBr(latch);
+        }
+
+        builder.SetInsertPoint(latch);
+        llvm::Value *cond = gen(child[0]);
+        if (cond == nullptr) return nullptr;
+        llvm::Value *again = builder.CreateICmpEQ(as_int(cond), builder.getInt64(0));
+        frame_release(mark);
+        builder.CreateCondBr(again, body_bb, exit_bb);
+
+        builder.SetInsertPoint(exit_bb);
+        frame_release(mark);
+        return make_none();
+    }
+
+    llvm::Value *gen_for(const std::shared_ptr<Node> &node) {
+        NodeList child = node->get_child();
+        // Evaluation order matches visit_for: assign, step (default 1), end.
+        llvm::Value *init = gen(child[0]);
+        if (init == nullptr) return nullptr;
+        llvm::Value *step = child[2] != nullptr ? gen(child[2]) : make_int(1);
+        if (step == nullptr) return nullptr;
+        llvm::Value *end = gen(child[1]);
+        if (end == nullptr) return nullptr;
+        builder.CreateCall(get_rt("rt_for_step_check", builder.getVoidTy(),
+                                  {ptr_ty}),
+                           {step});
+
+        const std::string var_name = child[0]->get_name();
+        llvm::AllocaInst *slot = entry_alloca(ptr_ty);
+        builder.CreateStore(init, slot);
+
+        // Dedicated frame keeping the latest loop-variable value alive even if
+        // the body rebinds the variable (the interpreter holds it in a local).
+        llvm::Value *var_frame = frame_mark();
+        frame_push();
+        llvm::Value *iter_mark = frame_mark();
+
+        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock *header = llvm::BasicBlock::Create(ctx, "for.cond", fn);
+        llvm::BasicBlock *body_bb = llvm::BasicBlock::Create(ctx, "for.body", fn);
+        llvm::BasicBlock *latch = llvm::BasicBlock::Create(ctx, "for.latch", fn);
+        llvm::BasicBlock *exit_bb = llvm::BasicBlock::Create(ctx, "for.exit", fn);
+        builder.CreateBr(header);
+
+        builder.SetInsertPoint(header);
+        llvm::Value *keep_going = builder.CreateICmpNE(
+            builder.CreateCall(get_rt("rt_for_cond", i64_ty, {ptr_ty, ptr_ty, ptr_ty}),
+                               {builder.CreateLoad(ptr_ty, slot), end, step}),
+            builder.getInt64(0));
+        builder.CreateCondBr(keep_going, body_bb, exit_bb);
+
+        builder.SetInsertPoint(body_bb);
+        frame_push();
+        loops.push_back({latch, exit_bb, iter_mark, false});
+        bool terminated = gen_body(NodeList(child.begin() + 3, child.end()));
+        loops.pop_back();
+        if (!errors.empty()) return nullptr;
+        if (!terminated) {
+            builder.CreateBr(latch);
+        }
+
+        // Latch mirrors visit_for: the next value comes from the value read at
+        // the previous latch, not from body reassignments of the variable.
+        builder.SetInsertPoint(latch);
+        llvm::Value *next = builder.CreateCall(
+            get_rt("rt_bin_op", ptr_ty, {i64_ty, ptr_ty, ptr_ty}),
+            {builder.getInt64(RT_OP_ADD), builder.CreateLoad(ptr_ty, slot), step});
+        builder.CreateCall(get_rt("rt_set_var", ptr_ty, {ptr_ty, ptr_ty}),
+                           {cstring(var_name), next});
+        builder.CreateCall(get_rt("rt_loop_keep", builder.getVoidTy(),
+                                  {i64_ty, ptr_ty}),
+                           {var_frame, next});
+        builder.CreateStore(next, slot);
+        frame_release(iter_mark);
+        builder.CreateBr(header);
+
+        builder.SetInsertPoint(exit_bb);
+        frame_release(var_frame);
+        return make_none();
+    }
+
+    // Emits a loop body (one or more statements). Returns true when the body
+    // terminated the current block (break/continue/return on every path).
+    bool gen_body(const NodeList &body) {
+        for (const auto &stmt : body) {
+            if (gen(stmt) == nullptr) {
+                return block_terminated() || !errors.empty();
+            }
+        }
+        return false;
+    }
+
+    llvm::Value *gen_loop_jump(const std::shared_ptr<Node> &node, bool is_break) {
+        if (loops.empty()) {
+            error(std::string("compile error: ") +
+                      (is_break ? "break" : "continue") +
+                      " outside of a loop is not supported by the compiler",
+                  node);
+            return nullptr;
+        }
+        const LoopContext &loop = loops.back();
+        if (is_break) {
+            frame_release(loop.iter_mark);
+            builder.CreateBr(loop.exit);
+        } else {
+            if (loop.release_on_continue) {
+                frame_release(loop.iter_mark);
+            }
+            builder.CreateBr(loop.latch);
+        }
+        return nullptr;
+    }
+
+    llvm::Value *gen_return(const std::shared_ptr<Node> &node) {
+        llvm::Value *value = gen(node->get_child()[0]);
+        if (value == nullptr) return nullptr;
+        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        if (fn->getName() == "main") {
+            // Top-level `return` does not stop execution in the interpreter.
+            return value;
+        }
+        builder.CreateRet(value);
+        return nullptr;
+    }
+
+    /// ---- functions and calls ----
+
+    llvm::Value *gen_algo_def(const std::shared_ptr<Node> &node) {
+        const std::string name = node->get_name();
+        if (name.find("::") != std::string::npos) {
+            error("compile error: Struct is not supported by the compiler yet",
+                  node);
+            return nullptr;
+        }
+
+        AlgorithmDefNode *def = dynamic_cast<AlgorithmDefNode *>(node.get());
+        std::vector<std::string> arg_names;
+        for (const auto &tok : node->get_toks()) {
+            arg_names.push_back(tok->get_value());
+        }
+
+        llvm::Function *fn = llvm::Function::Create(
+            llvm::FunctionType::get(ptr_ty, false), llvm::Function::PrivateLinkage,
+            "ps.algo." + std::to_string(algo_counter++) + "." + name, module);
+
+        llvm::IRBuilderBase::InsertPoint saved = builder.saveIP();
+        std::vector<LoopContext> saved_loops;
+        saved_loops.swap(loops);
+
+        llvm::BasicBlock *entry = llvm::BasicBlock::Create(ctx, "entry", fn);
+        builder.SetInsertPoint(entry);
+        llvm::Value *last = gen_statements(def->get_body());
+        if (!block_terminated() && errors.empty()) {
+            builder.CreateRet(last != nullptr ? last : make_none());
+        }
+
+        loops.swap(saved_loops);
+        builder.restoreIP(saved);
+        if (!errors.empty()) {
+            return nullptr;
+        }
+
+        // Registration happens at the definition site, like visit_algo_def.
+        llvm::ArrayType *names_ty = llvm::ArrayType::get(ptr_ty, arg_names.size());
+        std::vector<llvm::Constant *> name_ptrs;
+        for (const auto &arg : arg_names) {
+            name_ptrs.push_back(llvm::cast<llvm::Constant>(cstring(arg)));
+        }
+        auto *names_global = new llvm::GlobalVariable(
+            module, names_ty, true, llvm::GlobalValue::PrivateLinkage,
+            llvm::ConstantArray::get(names_ty, name_ptrs), "args");
+        return builder.CreateCall(
+            get_rt("rt_define_algo", ptr_ty, {ptr_ty, ptr_ty, ptr_ty, i64_ty}),
+            {cstring(name), fn, names_global,
+             builder.getInt64(static_cast<int64_t>(arg_names.size()))});
+    }
+
+    llvm::Value *gen_algo_call(const std::shared_ptr<Node> &node) {
+        AlgorithmCallNode *call = dynamic_cast<AlgorithmCallNode *>(node.get());
+        std::shared_ptr<Node> callee_node = call->get_call();
+        llvm::Value *callee;
+        if (callee_node->get_type() == NODE_VARACCESS) {
+            callee = gen_var_access(callee_node);
+        } else {
+            callee = gen(callee_node);
+        }
+        if (callee == nullptr) return nullptr;
+
+        const NodeList &args = call->get_args();
+        llvm::Value *argv;
+        if (args.empty()) {
+            argv = llvm::ConstantPointerNull::get(ptr_ty);
+        } else {
+            llvm::ArrayType *argv_ty = llvm::ArrayType::get(ptr_ty, args.size());
+            llvm::Function *fn = builder.GetInsertBlock()->getParent();
+            llvm::IRBuilder<> tmp(&fn->getEntryBlock(), fn->getEntryBlock().begin());
+            llvm::AllocaInst *slots = tmp.CreateAlloca(argv_ty);
+            for (size_t i = 0; i < args.size(); ++i) {
+                llvm::Value *arg = gen(args[i]);
+                if (arg == nullptr) return nullptr;
+                builder.CreateStore(
+                    arg, builder.CreateConstInBoundsGEP2_64(argv_ty, slots, 0, i));
+            }
+            argv = slots;
+        }
+        return builder.CreateCall(
+            get_rt("rt_call", ptr_ty, {ptr_ty, ptr_ty, i64_ty}),
+            {callee, argv, builder.getInt64(static_cast<int64_t>(args.size()))});
+    }
+
+    /// ---- arrays, hash tables, members ----
+
+    llvm::Value *gen_array(const std::shared_ptr<Node> &node) {
+        llvm::Value *array = builder.CreateCall(get_rt("rt_array_new", ptr_ty, {}));
+        for (const auto &element : node->get_child()) {
+            llvm::Value *value = gen(element);
+            if (value == nullptr) return nullptr;
+            builder.CreateCall(get_rt("rt_array_push", builder.getVoidTy(),
+                                      {ptr_ty, ptr_ty}),
+                               {array, value});
+        }
+        return array;
+    }
+
+    llvm::Value *gen_array_access(const std::shared_ptr<Node> &node) {
+        NodeList child = node->get_child();
+        llvm::Value *container = gen(child[0]);
+        if (container == nullptr) return nullptr;
+        llvm::Value *index = gen(child[1]);
+        if (index == nullptr) return nullptr;
+        return builder.CreateCall(get_rt("rt_index", ptr_ty, {ptr_ty, ptr_ty}),
+                                  {container, index});
+    }
+
+    llvm::Value *gen_array_assign(const std::shared_ptr<Node> &node) {
+        NodeList child = node->get_child();
+        if (child[0]->get_type() == NODE_MEMACCESS) {
+            NodeList member_child = child[0]->get_child();
+            llvm::Value *object = gen(member_child[0]);
+            if (object == nullptr) return nullptr;
+            llvm::Value *value = gen(child[1]);
+            if (value == nullptr) return nullptr;
+            return builder.CreateCall(
+                get_rt("rt_member_assign", ptr_ty, {ptr_ty, ptr_ty, ptr_ty}),
+                {object, cstring(member_child[1]->get_name()), value});
+        }
+        if (child[0]->get_type() != NODE_ARRACCESS) {
+            error("compile error: assignment target must be an array element or "
+                  "object member",
+                  node);
+            return nullptr;
+        }
+        NodeList access_child = child[0]->get_child();
+        llvm::Value *container = gen(access_child[0]);
+        if (container == nullptr) return nullptr;
+        llvm::Value *index = gen(access_child[1]);
+        if (index == nullptr) return nullptr;
+        llvm::Value *value = gen(child[1]);
+        if (value == nullptr) return nullptr;
+        return builder.CreateCall(
+            get_rt("rt_index_assign", ptr_ty, {ptr_ty, ptr_ty, ptr_ty}),
+            {container, index, value});
+    }
+
+    llvm::Value *gen_member_access(const std::shared_ptr<Node> &node) {
+        NodeList child = node->get_child();
+        llvm::Value *object = gen(child[0]);
+        if (object == nullptr) return nullptr;
+        return builder.CreateCall(
+            get_rt("rt_member_access", ptr_ty, {ptr_ty, ptr_ty}),
+            {object, cstring(child[1]->get_name())});
+    }
+};
+
+} // namespace
+
+bool Compiler::compile(const NodeList &ast, llvm::Module &module,
+                       std::vector<std::string> &errors) {
+    CodeGen codegen(module, errors);
+    return codegen.run(ast);
+}
diff --git a/src/compiler.h b/src/compiler.h
new file mode 100644
index 0000000..f6b9488
--- /dev/null
+++ b/src/compiler.h
@@ -0,0 +1,25 @@
+/// --------------------
+/// LLVM AOT compiler
+/// --------------------
+
+#ifndef COMPILER_H
+#define COMPILER_H
+
+#include "node.h"
+#include <string>
+#include <vector>
+
+namespace llvm {
+class Module;
+} // namespace llvm
+
+class Compiler {
+public:
+    // Lowers the parsed program into `module` (a `main` function plus one
+    // function per Algorithm). Returns false and fills `errors` when the
+    // program uses features the compiler does not support.
+    static bool compile(const NodeList &ast, llvm::Module &module,
+                        std::vector<std::string> &errors);
+};
+
+#endif
diff --git a/src/pseudoc.cpp b/src/pseudoc.cpp
new file mode 100644
index 0000000..b5cec10
--- /dev/null
+++ b/src/pseudoc.cpp
@@ -0,0 +1,267 @@
+/// --------------------
+/// pseudoc driver
+/// --------------------
+///
+/// Compiles a .ps source file to a native executable:
+///   pseudoc <file.ps> [-o <out>] [--emit-llvm] [--runtime-lib <path>]
+
+#include "compiler.h"
+#include "error.h"
+#include "imports.h"
+#include "lexer.h"
+#include "node.h"
+#include "parser.h"
+#include "token.h"
+
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/LegacyPassManager.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/MC/TargetRegistry.h>
+#include <llvm/Passes/PassBuilder.h>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Target/TargetMachine.h>
+#include <llvm/TargetParser/Host.h>
+#include <llvm/TargetParser/Triple.h>
+
+#include <cstdlib>
+#include <filesystem>
+#include <unistd.h>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace {
+
+namespace fs = std::filesystem;
+
+void usage() {
+    std::cout << "usage: pseudoc <file.ps> [-o <output>] [--emit-llvm] "
+                 "[--runtime-lib <path>]\n";
+}
+
+std::string find_runtime_lib(const std::string &flag_value, const char *argv0) {
+    std::vector<fs::path> candidates;
+    if (!flag_value.empty()) {
+        candidates.emplace_back(flag_value);
+    }
+    if (const char *env = std::getenv("PSEUDO_RT_LIB")) {
+        candidates.emplace_back(env);
+    }
+    std::error_code ec;
+    fs::path exe = fs::weakly_canonical(fs::path(argv0), ec);
+    if (!ec && exe.has_parent_path()) {
+        candidates.push_back(exe.parent_path() / "build" / "libpseudort.a");
+    }
+    candidates.push_back(fs::current_path() / "build" / "libpseudort.a");
+
+    for (const auto &candidate : candidates) {
+        if (fs::exists(candidate, ec) && fs::is_regular_file(candidate, ec)) {
+            return candidate.string();
+        }
+    }
+    return "";
+}
+
+std::string shell_quote(const std::string &text) {
+    std::string quoted = "'";
+    for (char c : text) {
+        if (c == '\'') {
+            quoted += "'\\''";
+        } else {
+            quoted += c;
+        }
+    }
+    quoted += "'";
+    return quoted;
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+    std::string input_path, output_path, runtime_lib_flag;
+    bool emit_llvm = false;
+    for (int i = 1; i < argc; ++i) {
+        std::string arg = argv[i];
+        if (arg == "-o" && i + 1 < argc) {
+            output_path = argv[++i];
+        } else if (arg == "--emit-llvm") {
+            emit_llvm = true;
+        } else if (arg == "--runtime-lib" && i + 1 < argc) {
+            runtime_lib_flag = argv[++i];
+        } else if (arg == "-h" || arg == "--help") {
+            usage();
+            return 0;
+        } else if (!arg.empty() && arg[0] == '-') {
+            std::cout << "unknown option: " << arg << "\n";
+            usage();
+            return 1;
+        } else if (input_path.empty()) {
+            input_path = arg;
+        } else {
+            usage();
+            return 1;
+        }
+    }
+    if (input_path.empty()) {
+        usage();
+        return 1;
+    }
+    if (output_path.empty()) {
+        output_path = fs::path(input_path).stem().string();
+        if (output_path.empty()) {
+            output_path = "a.out";
+        }
+    }
+
+    std::ifstream input(input_path);
+    if (!input) {
+        std::cout << "cannot open " << input_path << "\n";
+        return 1;
+    }
+    std::string code, line;
+    while (std::getline(input, line)) {
+        code += line + "\n";
+    }
+
+    ImportState import_state;
+    std::string expanded_text, import_error;
+    if (!expand_imports(input_path, code, import_state, expanded_text,
+                        import_error)) {
+        std::cout << import_error << "\n";
+        return 1;
+    }
+
+    Lexer lexer(input_path, expanded_text);
+    TokenList tokens = lexer.make_tokens();
+    for (const auto &tok : tokens) {
+        if (tok->get_type() == TOKEN_ERROR) {
+            std::cout << "Error: " << tok->get_value() << ", line "
+                      << tok->get_pos().line + 1
+                      << ", column: " << tok->get_pos().column << "\n";
+            std::cout << error_marker(expanded_text, tok->get_pos(),
+                                      tok->get_pos());
+            return 1;
+        }
+    }
+
+    Parser parser(tokens);
+    NodeList ast = parser.parse();
+    for (const auto &node : ast) {
+        if (node->get_type() == NODE_ERROR) {
+            std::shared_ptr<Token> err_tok = node->get_tok();
+            if (err_tok) {
+                std::cout << "Error: " << err_tok->get_value() << ", line "
+                          << err_tok->get_pos().line + 1
+                          << ", column: " << err_tok->get_pos().column << "\n";
+                std::cout << error_marker(expanded_text, err_tok->get_pos(),
+                                          err_tok->get_pos());
+            } else {
+                std::cout << "Error: " << node->get_node() << "\n";
+            }
+            return 1;
+        }
+    }
+
+    llvm::LLVMContext context;
+    llvm::Module module(input_path, context);
+    std::vector<std::string> compile_errors;
+    if (!Compiler::compile(ast, module, compile_errors)) {
+        for (const auto &message : compile_errors) {
+            std::cout << message << "\n";
+        }
+        return 1;
+    }
+
+    if (emit_llvm) {
+        module.print(llvm::outs(), nullptr);
+        return 0;
+    }
+
+    if (llvm::verifyModule(module, &llvm::errs())) {
+        std::cout << "internal error: generated module is invalid\n";
+        return 1;
+    }
+
+    llvm::InitializeNativeTarget();
+    llvm::InitializeNativeTargetAsmPrinter();
+    llvm::InitializeNativeTargetAsmParser();
+
+    std::string triple_name = llvm::sys::getDefaultTargetTriple();
+    std::string lookup_error;
+    const llvm::Target *target =
+        llvm::TargetRegistry::lookupTarget(triple_name, lookup_error);
+    if (target == nullptr) {
+        std::cout << "target lookup failed: " << lookup_error << "\n";
+        return 1;
+    }
+    llvm::TargetOptions target_options;
+    llvm::TargetMachine *machine = target->createTargetMachine(
+        llvm::Triple(triple_name), "generic", "", target_options,
+        llvm::Reloc::PIC_);
+    module.setDataLayout(machine->createDataLayout());
+    module.setTargetTriple(llvm::Triple(triple_name));
+
+    // Standard O2 pipeline.
+    llvm::LoopAnalysisManager lam;
+    llvm::FunctionAnalysisManager fam;
+    llvm::CGSCCAnalysisManager cgam;
+    llvm::ModuleAnalysisManager mam;
+    llvm::PassBuilder pass_builder(machine);
+    pass_builder.registerModuleAnalyses(mam);
+    pass_builder.registerCGSCCAnalyses(cgam);
+    pass_builder.registerFunctionAnalyses(fam);
+    pass_builder.registerLoopAnalyses(lam);
+    pass_builder.crossRegisterProxies(lam, fam, cgam, mam);
+    llvm::ModulePassManager mpm =
+        pass_builder.buildPerModuleDefaultPipeline(llvm::OptimizationLevel::O2);
+    mpm.run(module, mam);
+
+    fs::path object_path =
+        fs::temp_directory_path() /
+        ("pseudoc-" + std::to_string(::getpid()) + ".o");
+    {
+        std::error_code ec;
+        llvm::raw_fd_ostream object_stream(object_path.string(), ec,
+                                           llvm::sys::fs::OF_None);
+        if (ec) {
+            std::cout << "cannot write " << object_path.string() << ": "
+                      << ec.message() << "\n";
+            return 1;
+        }
+        llvm::legacy::PassManager emit_pm;
+        if (machine->addPassesToEmitFile(emit_pm, object_stream, nullptr,
+                                         llvm::CodeGenFileType::ObjectFile)) {
+            std::cout << "target cannot emit object files\n";
+            return 1;
+        }
+        emit_pm.run(module);
+    }
+
+    std::string runtime_lib = find_runtime_lib(runtime_lib_flag, argv[0]);
+    if (runtime_lib.empty()) {
+        std::cout << "cannot find libpseudort.a (build it with `make runtime`, "
+                     "or pass --runtime-lib)\n";
+        fs::remove(object_path);
+        return 1;
+    }
+
+    std::string linker = "c++";
+    if (const char *env = std::getenv("PSEUDO_LD")) {
+        linker = env;
+    }
+    std::string command = linker + " " + shell_quote(object_path.string()) +
+                          " " + shell_quote(runtime_lib) + " -o " +
+                          shell_quote(output_path);
+    int status = std::system(command.c_str());
+    fs::remove(object_path);
+    if (status != 0) {
+        std::cout << "link failed: " << command << "\n";
+        return 1;
+    }
+    return 0;
+}
diff --git a/src/runtime.cpp b/src/runtime.cpp
index ed33fce..51cb52c 100644
--- a/src/runtime.cpp
+++ b/src/runtime.cpp
@@ -260,8 +260,8 @@ Value *rt_member_assign(Value *obj, const char *name, Value *v) {
         VALUE_ERROR, "Assignment to member only supported for Struct Instances\n"));
 }
 
-void rt_define_algo(const char *name, Value *(*fn)(),
-                    const char *const *arg_names, int64_t nargs) {
+Value *rt_define_algo(const char *name, Value *(*fn)(),
+                      const char *const *arg_names, int64_t nargs) {
     std::vector<std::string> names;
     names.reserve(nargs);
     for (int64_t i = 0; i < nargs; ++i) {
@@ -270,7 +270,7 @@ void rt_define_algo(const char *name, Value *(*fn)(),
     std::shared_ptr<Value> algo =
         std::make_shared<CompiledAlgoValue>(name, fn, std::move(names));
     current_scope().set(name, algo);
-    track(algo);
+    return track(algo);
 }
 
 Value *rt_call(Value *callee, Value **argv, int64_t argc) {
@@ -304,4 +304,10 @@ void rt_frame_release(int64_t mark) {
     }
 }
 
+void rt_loop_keep(int64_t frame_index, Value *v) {
+    std::shared_ptr<Value> kept = ref(v);
+    frames[frame_index].clear();
+    frames[frame_index].push_back(kept);
+}
+
 } // extern "C"
diff --git a/src/runtime.h b/src/runtime.h
index 58c92ee..45dff6a 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -73,13 +73,16 @@ Value *rt_index_assign(Value *obj, Value *idx, Value *v);
 Value *rt_member_access(Value *obj, const char *name);
 Value *rt_member_assign(Value *obj, const char *name, Value *v);
 
-void rt_define_algo(const char *name, Value *(*fn)(),
-                    const char *const *arg_names, int64_t nargs);
+Value *rt_define_algo(const char *name, Value *(*fn)(),
+                      const char *const *arg_names, int64_t nargs);
 Value *rt_call(Value *callee, Value **argv, int64_t argc);
 
 int64_t rt_frame_mark();
 void rt_frame_push();
 void rt_frame_release(int64_t mark);
+// Replaces the contents of frame `frame_index` with just `v`: keeps the
+// current loop variable alive for one iteration without per-iteration growth.
+void rt_loop_keep(int64_t frame_index, Value *v);
 }
 
 #endif

From 3685846de4a6736c7c2d8f12d74ed0331807f97d Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:39:05 +0800
Subject: [PATCH 07/12] feat: memoize compiled pure-numeric algorithms, docs
 and CI updates

Shares the interpreter's is_memoizable_numeric_algo analysis (now in
src/analysis.h) so compiled recursive numeric algorithms get the same
by-argument caching. Documents the compile workflow in the README and makes
the clang-tidy CI script tolerate missing LLVM headers.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 README.md                                     |  36 +-
 ci/clang-tidy-check.sh                        |  13 +
 .../plans/2026-06-10-llvm-compiler.md         |  42 +-
 .../specs/2026-06-10-llvm-compiler-design.md  |  13 +
 pseudoc                                       | Bin 0 -> 845032 bytes
 src/analysis.h                                |  21 +
 src/compiler.cpp                              | 400 ++++++++----------
 src/compiler.h                                |  11 +-
 src/imports.h                                 |   5 +-
 src/pseudo.cpp                                |   5 +
 src/pseudoc.cpp                               |  72 ++--
 src/runtime.cpp                               | 226 +++++-----
 src/runtime.h                                 |  48 ++-
 13 files changed, 488 insertions(+), 404 deletions(-)
 create mode 100755 pseudoc
 create mode 100644 src/analysis.h

diff --git a/README.md b/README.md
index 9ff23c9..f314a24 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,40 @@
 # PseudoCodeInterpreter
 
-Transform pseudo-code into an executable programming language.
+Transform pseudo-code into an executable programming language. Programs can be
+run with the interpreter (`pseudo`) or compiled to native executables with the
+LLVM-based compiler (`pseudoc`).
+
+## Compiling to Native Code
+
+Requires LLVM (e.g. `brew install llvm`). Build and use the compiler:
+
+```sh
+make            # interpreter (used as reference by the test suite)
+make compiler   # builds pseudoc and build/libpseudort.a
+./pseudoc program.ps -o program
+./program
+```
+
+Options:
+
+- `-o <output>`: output executable path (defaults to the source basename).
+- `--emit-llvm`: print the generated LLVM IR instead of producing a binary.
+- `--runtime-lib <path>`: explicit path to `libpseudort.a` (also settable via
+  `$PSEUDO_RT_LIB`; by default it is found next to the `pseudoc` binary).
+
+The compiler lowers the AST to LLVM IR (optimized at `-O2`), where each
+language operation calls into a runtime built from the interpreter's own value
+and symbol-table code, so compiled behavior matches the interpreter. Recursive
+pure-numeric algorithms get the same by-argument memoization the interpreter
+applies. Compiled output is verified against the interpreter by
+`make test-compiler` (differential tests in `test/compiler/`).
+
+Current limitations:
+
+- `Struct` definitions are not supported yet (clear compile-time error);
+  `import` of struct-based modules such as `dsa` therefore also fails.
+- A loop used as a function's implicit return value evaluates to `NONE`
+  instead of the interpreter's collected per-iteration array.
 
 ## Data Types
 
diff --git a/ci/clang-tidy-check.sh b/ci/clang-tidy-check.sh
index b911c12..c5957f8 100755
--- a/ci/clang-tidy-check.sh
+++ b/ci/clang-tidy-check.sh
@@ -16,9 +16,21 @@ else
     fi
 fi
 
+# src/compiler.cpp and src/pseudoc.cpp need LLVM headers; skip them when no
+# LLVM development install is available.
+llvm_config="$(command -v llvm-config || echo /opt/homebrew/opt/llvm/bin/llvm-config)"
+llvm_flags=()
+llvm_filter='cat'
+if "${llvm_config}" --includedir >/dev/null 2>&1; then
+    llvm_flags=("-I$(${llvm_config} --includedir)")
+else
+    llvm_filter="grep -Ev '^src/(compiler|pseudoc)\\.cpp$'"
+fi
+
 mapfile -t files < <(
     printf '%s\n' "${changed_files}" \
         | grep -E '^(src|test)/.*\.cpp$' \
+        | eval "${llvm_filter}" \
         || true
 )
 
@@ -31,4 +43,5 @@ clang-tidy --warnings-as-errors='*' "${files[@]}" -- \
     -std=c++17 \
     -Isrc \
     -Igoogletest/googletest/include \
+    "${llvm_flags[@]}" \
     -pthread
diff --git a/docs/superpowers/plans/2026-06-10-llvm-compiler.md b/docs/superpowers/plans/2026-06-10-llvm-compiler.md
index f14e2dc..a4c2b32 100644
--- a/docs/superpowers/plans/2026-06-10-llvm-compiler.md
+++ b/docs/superpowers/plans/2026-06-10-llvm-compiler.md
@@ -17,9 +17,9 @@
 - Create: `test/compiler/basics.ps`, `test/compiler/control_flow.ps`, `test/compiler/functions.ps`, `test/compiler/collections.ps`, `test/compiler/errors.ps`
 - Modify: `Makefile` (add `test-compiler` target)
 
-- [ ] **Step 1:** Write `test/compiler_tests.sh`: for each `.ps` in `test/compiler/` plus `test/test_fib.ps`, `test/test_repeat.ps`, `test/test_array_methods.ps`, `test/test_string_index.ps`, run `./pseudo f.ps > expected`, `./pseudoc f.ps -o tmpbin && ./tmpbin > actual`, diff. Exit nonzero on any mismatch. Also assert `./pseudoc test/test_struct.ps` fails with a struct compile error.
-- [ ] **Step 2:** Write the five new `.ps` fixtures covering: int/float/string arithmetic and comparisons, `and/or/not`, unary minus, `^` and `%`; if/else-if chains, for with step (incl. negative), while/repeat with break/continue, nested loops; recursion (fib), functions using caller scope, too-few-args error; arrays (literal, index assign, push/pop/insert/remove/resize/size/back), hash tables (set/get/contains/keys/size), string indexing and concatenation; index-out-of-range error.
-- [ ] **Step 3:** Run `bash test/compiler_tests.sh` — must FAIL (`pseudoc` missing). Commit.
+- [x] **Step 1:** Write `test/compiler_tests.sh`: for each `.ps` in `test/compiler/` plus `test/test_fib.ps`, `test/test_repeat.ps`, `test/test_array_methods.ps`, `test/test_string_index.ps`, run `./pseudo f.ps > expected`, `./pseudoc f.ps -o tmpbin && ./tmpbin > actual`, diff. Exit nonzero on any mismatch. Also assert `./pseudoc test/test_struct.ps` fails with a struct compile error.
+- [x] **Step 2:** Write the five new `.ps` fixtures covering: int/float/string arithmetic and comparisons, `and/or/not`, unary minus, `^` and `%`; if/else-if chains, for with step (incl. negative), while/repeat with break/continue, nested loops; recursion (fib), functions using caller scope, too-few-args error; arrays (literal, index assign, push/pop/insert/remove/resize/size/back), hash tables (set/get/contains/keys/size), string indexing and concatenation; index-out-of-range error.
+- [x] **Step 3:** Run `bash test/compiler_tests.sh` — must FAIL (`pseudoc` missing). Commit.
 
 ### Task 2: Minimal intrusive changes to interpreter core
 
@@ -30,7 +30,7 @@
 - Create: `src/imports.h`
 - Modify: `src/pseudo.cpp` (move `ImportState`/`expand_imports` out of anonymous namespace, include `imports.h`)
 
-- [ ] **Step 1:** `class Value : public std::enable_shared_from_this<Value>`; add
+- [x] **Step 1:** `class Value : public std::enable_shared_from_this<Value>`; add
 
 ```cpp
 class PrecomputedNode : public Node {
@@ -44,8 +44,8 @@ protected:
 };
 ```
 
-- [ ] **Step 2:** `imports.h` declares `struct ImportState` and `bool expand_imports(const std::string&, const std::string&, ImportState&, std::string&, std::string&);` matching the current pseudo.cpp definitions.
-- [ ] **Step 3:** `make clean && make && make test` — all existing gtests PASS. Run an example to sanity-check. Commit.
+- [x] **Step 2:** `imports.h` declares `struct ImportState` and `bool expand_imports(const std::string&, const std::string&, ImportState&, std::string&, std::string&);` matching the current pseudo.cpp definitions.
+- [x] **Step 3:** `make clean && make && make test` — all existing gtests PASS. Run an example to sanity-check. Commit.
 
 ### Task 3: Runtime library `libpseudort.a`
 
@@ -53,7 +53,7 @@ protected:
 - Create: `src/runtime.h`, `src/runtime.cpp`
 - Modify: `Makefile` (`runtime` target producing `build/libpseudort.a` from all interpreter objects except `shell.o`, plus `runtime.o`)
 
-- [ ] **Step 1:** `runtime.h` — extern "C" ABI (all value params/returns are raw `Value*` kept alive by arena frames):
+- [x] **Step 1:** `runtime.h` — extern "C" ABI (all value params/returns are raw `Value*` kept alive by arena frames):
 
 ```cpp
 extern "C" {
@@ -91,8 +91,8 @@ Value* rt_keep(Value* v, int64_t mark); // re-register v in frame `mark`-1 (surv
 }
 ```
 
-- [ ] **Step 2:** Implement in runtime.cpp: global `std::vector<std::vector<std::shared_ptr<Value>>> frames` and `std::vector<std::unique_ptr<SymbolTable>> scopes` (global scope created by `rt_init`); `CompiledAlgoValue : Value` holding `Value*(*fn)()` and arg names; `rt_call` dispatch (compiled → arity check with interpreter's exact colored error strings, new scope + frame, bind args, invoke; otherwise wrap args in `PrecomputedNode` and call `callee->execute(nodes, current_scope)`). Binary/unary ops call the existing `operator+` etc. on `shared_from_this()` handles. Any `VALUE_ERROR` encountered → print `get_num()` + `"\n"`, `exit(1)`.
-- [ ] **Step 3:** `make runtime` builds `build/libpseudort.a`. Commit.
+- [x] **Step 2:** Implement in runtime.cpp: global `std::vector<std::vector<std::shared_ptr<Value>>> frames` and `std::vector<std::unique_ptr<SymbolTable>> scopes` (global scope created by `rt_init`); `CompiledAlgoValue : Value` holding `Value*(*fn)()` and arg names; `rt_call` dispatch (compiled → arity check with interpreter's exact colored error strings, new scope + frame, bind args, invoke; otherwise wrap args in `PrecomputedNode` and call `callee->execute(nodes, current_scope)`). Binary/unary ops call the existing `operator+` etc. on `shared_from_this()` handles. Any `VALUE_ERROR` encountered → print `get_num()` + `"\n"`, `exit(1)`.
+- [x] **Step 3:** `make runtime` builds `build/libpseudort.a`. Commit.
 
 ### Task 4: Compiler skeleton + driver (milestone: arithmetic & print)
 
@@ -101,33 +101,33 @@ Value* rt_keep(Value* v, int64_t mark); // re-register v in frame `mark`-1 (surv
 - Create: `src/pseudoc.cpp` (driver: args, expand_imports, lex/parse with run()-style error printing, codegen, verify, O2 PassBuilder, TargetMachine object emission, link via `c++`)
 - Modify: `Makefile` (`compiler` target via `llvm-config`, default `/opt/homebrew/opt/llvm/bin/llvm-config` fallback; link `-lLLVM` from `--libdir` with rpath)
 
-- [ ] **Step 1:** Codegen for: ValueNode literals, VarAccess/VarAssign, BinOp/UnaryOp (`rt_bin_op` with op codes), AlgorithmCall (callee codegen + `rt_call`), statement sequencing in `main` (`rt_init` first, `ret i32 0` last). Unsupported node types → recorded compile error.
-- [ ] **Step 2:** Driver `--emit-llvm` and `-o`; runtime archive lookup (`--runtime-lib`, `$PSEUDO_RT_LIB`, `<exe dir>/build/libpseudort.a`).
-- [ ] **Step 3:** `make compiler`; `echo 'print("hi", 1 + 2 * 3)' > /tmp/t.ps && ./pseudoc /tmp/t.ps -o /tmp/t && /tmp/t` matches `./pseudo /tmp/t.ps`. Commit.
+- [x] **Step 1:** Codegen for: ValueNode literals, VarAccess/VarAssign, BinOp/UnaryOp (`rt_bin_op` with op codes), AlgorithmCall (callee codegen + `rt_call`), statement sequencing in `main` (`rt_init` first, `ret i32 0` last). Unsupported node types → recorded compile error.
+- [x] **Step 2:** Driver `--emit-llvm` and `-o`; runtime archive lookup (`--runtime-lib`, `$PSEUDO_RT_LIB`, `<exe dir>/build/libpseudort.a`).
+- [x] **Step 3:** `make compiler`; `echo 'print("hi", 1 + 2 * 3)' > /tmp/t.ps && ./pseudoc /tmp/t.ps -o /tmp/t && /tmp/t` matches `./pseudo /tmp/t.ps`. Commit.
 
 ### Task 5: Control flow
 
 **Files:**
 - Modify: `src/compiler.cpp`
 
-- [ ] **Step 1:** `if` (yields Int 0 when untaken, propagates last-statement value), `for` (assign → step default/check → end; latch keeps previous `i` slot per visit_for; per-iteration `rt_frame_mark`/`rt_frame_release`), `while`, `repeat`, `break`/`continue` (branch + release to loop mark), nested loops via a loop-context stack.
-- [ ] **Step 2:** Differential run of `test/compiler/control_flow.ps`, `test/test_repeat.ps` — PASS. Commit.
+- [x] **Step 1:** `if` (yields Int 0 when untaken, propagates last-statement value), `for` (assign → step default/check → end; latch keeps previous `i` slot per visit_for; per-iteration `rt_frame_mark`/`rt_frame_release`), `while`, `repeat`, `break`/`continue` (branch + release to loop mark), nested loops via a loop-context stack.
+- [x] **Step 2:** Differential run of `test/compiler/control_flow.ps`, `test/test_repeat.ps` — PASS. Commit.
 
 ### Task 6: Functions and return
 
 **Files:**
 - Modify: `src/compiler.cpp`
 
-- [ ] **Step 1:** AlgorithmDef → new LLVM function compiled with its own builder state (body statements; implicit result = last statement value; `ReturnNode` → `rt_keep` + `ret`); definition site emits `rt_define_algo` with arg-name global strings. Same handling when defs appear inside other bodies.
-- [ ] **Step 2:** Differential run of `test/compiler/functions.ps`, `test/test_fib.ps` — PASS. Commit.
+- [x] **Step 1:** AlgorithmDef → new LLVM function compiled with its own builder state (body statements; implicit result = last statement value; `ReturnNode` → `rt_keep` + `ret`); definition site emits `rt_define_algo` with arg-name global strings. Same handling when defs appear inside other bodies.
+- [x] **Step 2:** Differential run of `test/compiler/functions.ps`, `test/test_fib.ps` — PASS. Commit.
 
 ### Task 7: Arrays, hash tables, strings, member calls
 
 **Files:**
 - Modify: `src/compiler.cpp`
 
-- [ ] **Step 1:** ArrayNode literal, ArrayAccess (`rt_index`), ArrayAssign (`rt_index_assign`, including hash-table set; member assignment on non-instances reports the interpreter's error string at runtime), MemberAccess (`rt_member_access` → BoundMethodValue path; method calls flow through existing `rt_call` fallback).
-- [ ] **Step 2:** Differential run of `test/compiler/collections.ps`, `test/test_array_methods.ps`, `test/test_string_index.ps` — PASS. Commit.
+- [x] **Step 1:** ArrayNode literal, ArrayAccess (`rt_index`), ArrayAssign (`rt_index_assign`, including hash-table set; member assignment on non-instances reports the interpreter's error string at runtime), MemberAccess (`rt_member_access` → BoundMethodValue path; method calls flow through existing `rt_call` fallback).
+- [x] **Step 2:** Differential run of `test/compiler/collections.ps`, `test/test_array_methods.ps`, `test/test_string_index.ps` — PASS. Commit.
 
 ### Task 8: Struct rejection, error fixtures, full suite
 
@@ -135,9 +135,9 @@ Value* rt_keep(Value* v, int64_t mark); // re-register v in frame `mark`-1 (surv
 - Modify: `src/compiler.cpp` (NODE_STRUCTDEF → "compile error: Struct is not supported by the compiler yet" with location; same for instance member assignment when detectable)
 - Modify: `Makefile` (`test-compiler` runs harness)
 
-- [ ] **Step 1:** `bash test/compiler_tests.sh` — ALL PASS (including struct rejection and runtime error fixtures).
-- [ ] **Step 2:** `make test` still green; `ci/clang-format-check.sh` clean (format new files).
-- [ ] **Step 3:** Update README (compile section). Commit.
+- [x] **Step 1:** `bash test/compiler_tests.sh` — ALL PASS (including struct rejection and runtime error fixtures).
+- [x] **Step 2:** `make test` still green; `ci/clang-format-check.sh` clean (format new files).
+- [x] **Step 3:** Update README (compile section). Commit.
 
 ## Self-review notes
 
diff --git a/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md b/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
index 06dca7d..bafbede 100644
--- a/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
+++ b/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
@@ -91,6 +91,19 @@ its `shared_ptr` in the current frame. Frames are pushed/popped:
   `err->get_num()` (same text the interpreter prints at top level) and exits
   with status 1. There is no error-value plumbing in generated IR.
 
+### Documented v1 divergences from the interpreter
+
+- A loop used as a function's implicit return value evaluates to `NONE`;
+  the interpreter (with `collect_loop_results`) returns an array of
+  per-iteration values. Rarely used; revisit if needed.
+- `break`/`continue` outside any loop are compile-time errors (the
+  interpreter propagates them as control values, which can even break an
+  outer loop across a function call — pathological behavior we do not
+  reproduce).
+- Compiled recursive pure-numeric algorithms get the interpreter's
+  by-argument memoization via `rt_define_algo(..., memoizable)`, using the
+  shared `is_memoizable_numeric_algo` analysis (src/analysis.h).
+
 ### Unsupported in v1 (clean compile-time error)
 
 - `Struct` definitions / instances (`NODE_STRUCTDEF`, member assignment on
diff --git a/pseudoc b/pseudoc
new file mode 100755
index 0000000000000000000000000000000000000000..e722f99b4b067f7e325d5ef9e44cf96fce1dac27
GIT binary patch
literal 845032
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%0Dlr(1O6(w
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
Y!*i!jv}=BHY{Qg;x@A!oM84+#0UdFY{r~^~

literal 0
HcmV?d00001

diff --git a/src/analysis.h b/src/analysis.h
new file mode 100644
index 0000000..018f294
--- /dev/null
+++ b/src/analysis.h
@@ -0,0 +1,21 @@
+/// --------------------
+/// Algorithm analysis
+/// --------------------
+
+#ifndef ANALYSIS_H
+#define ANALYSIS_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "node.h"
+
+// True for recursive algorithms whose bodies only use numeric literals, their
+// own arguments, numeric operators, ifs, and self-calls: their results can be
+// memoized by argument values (used by both the interpreter and the compiled
+// runtime).
+bool is_memoizable_numeric_algo(const std::shared_ptr<Node>& node, const std::string& algo_name,
+                                const std::vector<std::string>& args);
+
+#endif
diff --git a/src/compiler.cpp b/src/compiler.cpp
index 6d774f9..e45b0aa 100644
--- a/src/compiler.cpp
+++ b/src/compiler.cpp
@@ -8,9 +8,6 @@
 /// docs/superpowers/specs/2026-06-10-llvm-compiler-design.md.
 
 #include "compiler.h"
-#include "node.h"
-#include "runtime.h"
-#include "token.h"
 
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/DerivedTypes.h>
@@ -24,27 +21,31 @@
 #include <string>
 #include <vector>
 
+#include "analysis.h"
+#include "node.h"
+#include "runtime.h"
+#include "token.h"
+
 namespace {
 
 class CodeGen {
-public:
-    CodeGen(llvm::Module &_module, std::vector<std::string> &_errors)
-        : module(_module), ctx(_module.getContext()), builder(ctx),
-          errors(_errors) {
+   public:
+    CodeGen(llvm::Module& _module, std::vector<std::string>& _errors)
+        : module(_module), ctx(_module.getContext()), builder(ctx), errors(_errors) {
         ptr_ty = builder.getPtrTy();
         i64_ty = builder.getInt64Ty();
         f64_ty = builder.getDoubleTy();
     }
 
-    bool run(const NodeList &ast) {
-        llvm::Function *main_fn = llvm::Function::Create(
-            llvm::FunctionType::get(builder.getInt32Ty(), false),
-            llvm::Function::ExternalLinkage, "main", module);
-        llvm::BasicBlock *entry = llvm::BasicBlock::Create(ctx, "entry", main_fn);
+    bool run(const NodeList& ast) {
+        llvm::Function* main_fn =
+            llvm::Function::Create(llvm::FunctionType::get(builder.getInt32Ty(), false),
+                                   llvm::Function::ExternalLinkage, "main", module);
+        llvm::BasicBlock* entry = llvm::BasicBlock::Create(ctx, "entry", main_fn);
         builder.SetInsertPoint(entry);
         builder.CreateCall(get_rt("rt_init", builder.getVoidTy(), {}));
 
-        for (const auto &node : ast) {
+        for (const auto& node : ast) {
             if (gen(node) == nullptr && block_terminated()) {
                 break;
             }
@@ -55,58 +56,55 @@ class CodeGen {
         return errors.empty();
     }
 
-private:
+   private:
     struct LoopContext {
-        llvm::BasicBlock *latch;
-        llvm::BasicBlock *exit;
-        llvm::Value *iter_mark;
+        llvm::BasicBlock* latch;
+        llvm::BasicBlock* exit;
+        llvm::Value* iter_mark;
         // `while` re-pushes its iteration frame in the header, so `continue`
         // must release first; `for`/`repeat` latches release it themselves.
         bool release_on_continue;
     };
 
-    llvm::Module &module;
-    llvm::LLVMContext &ctx;
+    llvm::Module& module;
+    llvm::LLVMContext& ctx;
     llvm::IRBuilder<> builder;
-    std::vector<std::string> &errors;
+    std::vector<std::string>& errors;
 
-    llvm::PointerType *ptr_ty{nullptr};
-    llvm::Type *i64_ty{nullptr};
-    llvm::Type *f64_ty{nullptr};
+    llvm::PointerType* ptr_ty{nullptr};
+    llvm::Type* i64_ty{nullptr};
+    llvm::Type* f64_ty{nullptr};
 
     std::vector<LoopContext> loops;
-    std::map<std::string, llvm::Value *> string_constants;
+    std::map<std::string, llvm::Value*> string_constants;
     int algo_counter{0};
 
     /// ---- helpers ----
 
-    llvm::FunctionCallee get_rt(const std::string &name, llvm::Type *ret,
-                                std::vector<llvm::Type *> args) {
-        return module.getOrInsertFunction(
-            name, llvm::FunctionType::get(ret, args, false));
+    llvm::FunctionCallee get_rt(const std::string& name, llvm::Type* ret,
+                                std::vector<llvm::Type*> args) {
+        return module.getOrInsertFunction(name, llvm::FunctionType::get(ret, args, false));
     }
 
-    bool block_terminated() {
-        return builder.GetInsertBlock()->getTerminator() != nullptr;
-    }
+    bool block_terminated() { return builder.GetInsertBlock()->getTerminator() != nullptr; }
 
-    llvm::Value *cstring(const std::string &text) {
+    llvm::Value* cstring(const std::string& text) {
         auto found = string_constants.find(text);
         if (found != string_constants.end()) {
             return found->second;
         }
-        llvm::Value *global = builder.CreateGlobalString(text, "str");
+        llvm::Value* global = builder.CreateGlobalString(text, "str");
         string_constants[text] = global;
         return global;
     }
 
-    llvm::AllocaInst *entry_alloca(llvm::Type *type) {
-        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+    llvm::AllocaInst* entry_alloca(llvm::Type* type) {
+        llvm::Function* fn = builder.GetInsertBlock()->getParent();
         llvm::IRBuilder<> tmp(&fn->getEntryBlock(), fn->getEntryBlock().begin());
         return tmp.CreateAlloca(type);
     }
 
-    void error(const std::string &message, const std::shared_ptr<Node> &node) {
+    void error(const std::string& message, const std::shared_ptr<Node>& node) {
         std::string suffix;
         std::shared_ptr<Token> tok = node ? node->get_tok() : nullptr;
         if (tok) {
@@ -115,26 +113,18 @@ class CodeGen {
         errors.push_back(message + suffix);
     }
 
-    llvm::Value *make_none() {
-        return builder.CreateCall(get_rt("rt_make_none", ptr_ty, {}));
-    }
+    llvm::Value* make_none() { return builder.CreateCall(get_rt("rt_make_none", ptr_ty, {})); }
 
-    llvm::Value *make_int(int64_t v) {
-        return builder.CreateCall(get_rt("rt_make_int", ptr_ty, {i64_ty}),
-                                  {builder.getInt64(v)});
+    llvm::Value* make_int(int64_t v) {
+        return builder.CreateCall(get_rt("rt_make_int", ptr_ty, {i64_ty}), {builder.getInt64(v)});
     }
 
-    llvm::Value *frame_mark() {
-        return builder.CreateCall(get_rt("rt_frame_mark", i64_ty, {}));
-    }
+    llvm::Value* frame_mark() { return builder.CreateCall(get_rt("rt_frame_mark", i64_ty, {})); }
 
-    void frame_push() {
-        builder.CreateCall(get_rt("rt_frame_push", builder.getVoidTy(), {}));
-    }
+    void frame_push() { builder.CreateCall(get_rt("rt_frame_push", builder.getVoidTy(), {})); }
 
-    void frame_release(llvm::Value *mark) {
-        builder.CreateCall(get_rt("rt_frame_release", builder.getVoidTy(), {i64_ty}),
-                           {mark});
+    void frame_release(llvm::Value* mark) {
+        builder.CreateCall(get_rt("rt_frame_release", builder.getVoidTy(), {i64_ty}), {mark});
     }
 
     /// ---- dispatch ----
@@ -142,7 +132,7 @@ class CodeGen {
     // Emits code for one node. Returns the node's value (an LLVM `ptr` to a
     // runtime Value) or nullptr when the node terminated the current block
     // (break/continue/return) or reported a compile error.
-    llvm::Value *gen(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen(const std::shared_ptr<Node>& node) {
         const std::string type = node->get_type();
         if (type == NODE_VALUE) return gen_literal(node);
         if (type == NODE_VARACCESS) return gen_var_access(node);
@@ -163,8 +153,7 @@ class CodeGen {
         if (type == NODE_BREAK) return gen_loop_jump(node, true);
         if (type == NODE_CONTINUE) return gen_loop_jump(node, false);
         if (type == NODE_STRUCTDEF) {
-            error("compile error: Struct is not supported by the compiler yet",
-                  node);
+            error("compile error: Struct is not supported by the compiler yet", node);
             return nullptr;
         }
         error("compile error: unsupported statement " + type, node);
@@ -173,9 +162,9 @@ class CodeGen {
 
     // Emits a statement sequence; returns the last statement's value, or
     // nullptr when the sequence terminated the block (or errored).
-    llvm::Value *gen_statements(const NodeList &nodes) {
-        llvm::Value *last = nullptr;
-        for (const auto &node : nodes) {
+    llvm::Value* gen_statements(const NodeList& nodes) {
+        llvm::Value* last = nullptr;
+        for (const auto& node : nodes) {
             last = gen(node);
             if (last == nullptr) {
                 return nullptr;
@@ -186,15 +175,14 @@ class CodeGen {
 
     /// ---- expressions ----
 
-    llvm::Value *gen_literal(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_literal(const std::shared_ptr<Node>& node) {
         std::shared_ptr<Token> tok = node->get_tok();
         if (tok->get_type() == TOKEN_INT) {
             return make_int(std::stoll(tok->get_value()));
         }
         if (tok->get_type() == TOKEN_FLOAT) {
-            return builder.CreateCall(
-                get_rt("rt_make_float", ptr_ty, {f64_ty}),
-                {llvm::ConstantFP::get(f64_ty, std::stod(tok->get_value()))});
+            return builder.CreateCall(get_rt("rt_make_float", ptr_ty, {f64_ty}),
+                                      {llvm::ConstantFP::get(f64_ty, std::stod(tok->get_value()))});
         }
         if (tok->get_type() == TOKEN_STRING) {
             return builder.CreateCall(get_rt("rt_make_string", ptr_ty, {ptr_ty}),
@@ -204,13 +192,13 @@ class CodeGen {
         return nullptr;
     }
 
-    llvm::Value *gen_var_access(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_var_access(const std::shared_ptr<Node>& node) {
         return builder.CreateCall(get_rt("rt_get_var", ptr_ty, {ptr_ty}),
                                   {cstring(node->get_name())});
     }
 
-    llvm::Value *gen_var_assign(const std::shared_ptr<Node> &node) {
-        llvm::Value *value = gen(node->get_child()[0]);
+    llvm::Value* gen_var_assign(const std::shared_ptr<Node>& node) {
+        llvm::Value* value = gen(node->get_child()[0]);
         if (value == nullptr) {
             return nullptr;
         }
@@ -218,11 +206,11 @@ class CodeGen {
                                   {cstring(node->get_name()), value});
     }
 
-    llvm::Value *as_int(llvm::Value *value) {
+    llvm::Value* as_int(llvm::Value* value) {
         return builder.CreateCall(get_rt("rt_as_int", i64_ty, {ptr_ty}), {value});
     }
 
-    llvm::Value *gen_bin_op(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_bin_op(const std::shared_ptr<Node>& node) {
         std::shared_ptr<Token> op = node->get_tok();
         if (op->get_type() == TOKEN_KEYWORD &&
             (op->get_value() == "and" || op->get_value() == "or")) {
@@ -230,12 +218,10 @@ class CodeGen {
         }
 
         static const std::map<std::string, int64_t> OP_CODES{
-            {TOKEN_ADD, RT_OP_ADD},     {TOKEN_SUB, RT_OP_SUB},
-            {TOKEN_MUL, RT_OP_MUL},     {TOKEN_DIV, RT_OP_DIV},
-            {TOKEN_MOD, RT_OP_MOD},     {TOKEN_POW, RT_OP_POW},
-            {TOKEN_EQUAL, RT_OP_EQUAL}, {TOKEN_NEQ, RT_OP_NEQ},
-            {TOKEN_LESS, RT_OP_LESS},   {TOKEN_GREATER, RT_OP_GREATER},
-            {TOKEN_LEQ, RT_OP_LEQ},     {TOKEN_GEQ, RT_OP_GEQ},
+            {TOKEN_ADD, RT_OP_ADD},         {TOKEN_SUB, RT_OP_SUB}, {TOKEN_MUL, RT_OP_MUL},
+            {TOKEN_DIV, RT_OP_DIV},         {TOKEN_MOD, RT_OP_MOD}, {TOKEN_POW, RT_OP_POW},
+            {TOKEN_EQUAL, RT_OP_EQUAL},     {TOKEN_NEQ, RT_OP_NEQ}, {TOKEN_LESS, RT_OP_LESS},
+            {TOKEN_GREATER, RT_OP_GREATER}, {TOKEN_LEQ, RT_OP_LEQ}, {TOKEN_GEQ, RT_OP_GEQ},
         };
         auto code = OP_CODES.find(op->get_type());
         if (code == OP_CODES.end()) {
@@ -244,30 +230,27 @@ class CodeGen {
         }
 
         NodeList child = node->get_child();
-        llvm::Value *lhs = gen(child[0]);
+        llvm::Value* lhs = gen(child[0]);
         if (lhs == nullptr) return nullptr;
-        llvm::Value *rhs = gen(child[1]);
+        llvm::Value* rhs = gen(child[1]);
         if (rhs == nullptr) return nullptr;
-        return builder.CreateCall(
-            get_rt("rt_bin_op", ptr_ty, {i64_ty, ptr_ty, ptr_ty}),
-            {builder.getInt64(code->second), lhs, rhs});
+        return builder.CreateCall(get_rt("rt_bin_op", ptr_ty, {i64_ty, ptr_ty, ptr_ty}),
+                                  {builder.getInt64(code->second), lhs, rhs});
     }
 
     // Mirrors visit_bin_op's short-circuit `and` / `or`: the result is always
     // an Int 0/1 derived from as_int().
-    llvm::Value *gen_short_circuit(const std::shared_ptr<Node> &node,
-                                   bool is_and) {
+    llvm::Value* gen_short_circuit(const std::shared_ptr<Node>& node, bool is_and) {
         NodeList child = node->get_child();
-        llvm::Value *lhs = gen(child[0]);
+        llvm::Value* lhs = gen(child[0]);
         if (lhs == nullptr) return nullptr;
 
-        llvm::Function *fn = builder.GetInsertBlock()->getParent();
-        llvm::BasicBlock *rhs_bb = llvm::BasicBlock::Create(ctx, "sc.rhs", fn);
-        llvm::BasicBlock *short_bb = llvm::BasicBlock::Create(ctx, "sc.short", fn);
-        llvm::BasicBlock *merge_bb = llvm::BasicBlock::Create(ctx, "sc.merge", fn);
+        llvm::Function* fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock* rhs_bb = llvm::BasicBlock::Create(ctx, "sc.rhs", fn);
+        llvm::BasicBlock* short_bb = llvm::BasicBlock::Create(ctx, "sc.short", fn);
+        llvm::BasicBlock* merge_bb = llvm::BasicBlock::Create(ctx, "sc.merge", fn);
 
-        llvm::Value *lhs_true =
-            builder.CreateICmpNE(as_int(lhs), builder.getInt64(0));
+        llvm::Value* lhs_true = builder.CreateICmpNE(as_int(lhs), builder.getInt64(0));
         if (is_and) {
             builder.CreateCondBr(lhs_true, rhs_bb, short_bb);
         } else {
@@ -275,25 +258,24 @@ class CodeGen {
         }
 
         builder.SetInsertPoint(short_bb);
-        llvm::Value *short_value = make_int(is_and ? 0 : 1);
+        llvm::Value* short_value = make_int(is_and ? 0 : 1);
         builder.CreateBr(merge_bb);
 
         builder.SetInsertPoint(rhs_bb);
-        llvm::Value *rhs = gen(child[1]);
+        llvm::Value* rhs = gen(child[1]);
         if (rhs == nullptr) return nullptr;
-        llvm::Value *rhs_value =
-            builder.CreateCall(get_rt("rt_bool", ptr_ty, {ptr_ty}), {rhs});
-        llvm::BasicBlock *rhs_end = builder.GetInsertBlock();
+        llvm::Value* rhs_value = builder.CreateCall(get_rt("rt_bool", ptr_ty, {ptr_ty}), {rhs});
+        llvm::BasicBlock* rhs_end = builder.GetInsertBlock();
         builder.CreateBr(merge_bb);
 
         builder.SetInsertPoint(merge_bb);
-        llvm::PHINode *phi = builder.CreatePHI(ptr_ty, 2);
+        llvm::PHINode* phi = builder.CreatePHI(ptr_ty, 2);
         phi->addIncoming(short_value, short_bb);
         phi->addIncoming(rhs_value, rhs_end);
         return phi;
     }
 
-    llvm::Value *gen_unary_op(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_unary_op(const std::shared_ptr<Node>& node) {
         std::shared_ptr<Token> op = node->get_tok();
         int64_t code;
         if (op->get_type() == TOKEN_ADD) {
@@ -303,11 +285,10 @@ class CodeGen {
         } else if (op->get_type() == TOKEN_KEYWORD && op->get_value() == "not") {
             code = RT_OP_UNOT;
         } else {
-            error("compile error: unsupported unary operator " + op->get_type(),
-                  node);
+            error("compile error: unsupported unary operator " + op->get_type(), node);
             return nullptr;
         }
-        llvm::Value *operand = gen(node->get_child()[0]);
+        llvm::Value* operand = gen(node->get_child()[0]);
         if (operand == nullptr) return nullptr;
         return builder.CreateCall(get_rt("rt_unary_op", ptr_ty, {i64_ty, ptr_ty}),
                                   {builder.getInt64(code), operand});
@@ -315,24 +296,24 @@ class CodeGen {
 
     /// ---- control flow ----
 
-    llvm::Value *gen_if(const std::shared_ptr<Node> &node) {
-        IfNode *if_node = dynamic_cast<IfNode *>(node.get());
-        llvm::Value *cond = gen(if_node->get_condition());
+    llvm::Value* gen_if(const std::shared_ptr<Node>& node) {
+        IfNode* if_node = dynamic_cast<IfNode*>(node.get());
+        llvm::Value* cond = gen(if_node->get_condition());
         if (cond == nullptr) return nullptr;
-        llvm::Value *taken = builder.CreateICmpNE(
+        llvm::Value* taken = builder.CreateICmpNE(
             builder.CreateCall(get_rt("rt_cond_eq1", i64_ty, {ptr_ty}), {cond}),
             builder.getInt64(0));
 
-        llvm::Function *fn = builder.GetInsertBlock()->getParent();
-        llvm::BasicBlock *then_bb = llvm::BasicBlock::Create(ctx, "if.then", fn);
-        llvm::BasicBlock *else_bb = llvm::BasicBlock::Create(ctx, "if.else", fn);
-        llvm::BasicBlock *merge_bb = llvm::BasicBlock::Create(ctx, "if.merge", fn);
-        llvm::AllocaInst *slot = entry_alloca(ptr_ty);
+        llvm::Function* fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock* then_bb = llvm::BasicBlock::Create(ctx, "if.then", fn);
+        llvm::BasicBlock* else_bb = llvm::BasicBlock::Create(ctx, "if.else", fn);
+        llvm::BasicBlock* merge_bb = llvm::BasicBlock::Create(ctx, "if.merge", fn);
+        llvm::AllocaInst* slot = entry_alloca(ptr_ty);
         builder.CreateCondBr(taken, then_bb, else_bb);
 
         bool merge_reachable = false;
         builder.SetInsertPoint(then_bb);
-        llvm::Value *then_value = gen_statements(if_node->get_expr());
+        llvm::Value* then_value = gen_statements(if_node->get_expr());
         if (!errors.empty()) return nullptr;
         if (then_value != nullptr) {
             builder.CreateStore(then_value, slot);
@@ -343,9 +324,8 @@ class CodeGen {
         }
 
         builder.SetInsertPoint(else_bb);
-        llvm::Value *else_value = if_node->get_else().empty()
-                                      ? make_int(0)
-                                      : gen_statements(if_node->get_else());
+        llvm::Value* else_value =
+            if_node->get_else().empty() ? make_int(0) : gen_statements(if_node->get_else());
         if (!errors.empty()) return nullptr;
         if (else_value != nullptr) {
             builder.CreateStore(else_value, slot);
@@ -363,22 +343,22 @@ class CodeGen {
         return builder.CreateLoad(ptr_ty, slot);
     }
 
-    llvm::Value *gen_while(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_while(const std::shared_ptr<Node>& node) {
         NodeList child = node->get_child();
-        llvm::Function *fn = builder.GetInsertBlock()->getParent();
-        llvm::BasicBlock *header = llvm::BasicBlock::Create(ctx, "while.cond", fn);
-        llvm::BasicBlock *body_bb = llvm::BasicBlock::Create(ctx, "while.body", fn);
-        llvm::BasicBlock *exit_bb = llvm::BasicBlock::Create(ctx, "while.exit", fn);
+        llvm::Function* fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock* header = llvm::BasicBlock::Create(ctx, "while.cond", fn);
+        llvm::BasicBlock* body_bb = llvm::BasicBlock::Create(ctx, "while.body", fn);
+        llvm::BasicBlock* exit_bb = llvm::BasicBlock::Create(ctx, "while.exit", fn);
 
-        llvm::Value *mark = frame_mark();
+        llvm::Value* mark = frame_mark();
         builder.CreateBr(header);
 
         // One arena frame per iteration covers the condition and the body.
         builder.SetInsertPoint(header);
         frame_push();
-        llvm::Value *cond = gen(child[0]);
+        llvm::Value* cond = gen(child[0]);
         if (cond == nullptr) return nullptr;
-        llvm::Value *enter = builder.CreateICmpEQ(as_int(cond), builder.getInt64(1));
+        llvm::Value* enter = builder.CreateICmpEQ(as_int(cond), builder.getInt64(1));
         builder.CreateCondBr(enter, body_bb, exit_bb);
 
         builder.SetInsertPoint(body_bb);
@@ -396,14 +376,14 @@ class CodeGen {
         return make_none();
     }
 
-    llvm::Value *gen_repeat(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_repeat(const std::shared_ptr<Node>& node) {
         NodeList child = node->get_child();
-        llvm::Function *fn = builder.GetInsertBlock()->getParent();
-        llvm::BasicBlock *body_bb = llvm::BasicBlock::Create(ctx, "repeat.body", fn);
-        llvm::BasicBlock *latch = llvm::BasicBlock::Create(ctx, "repeat.cond", fn);
-        llvm::BasicBlock *exit_bb = llvm::BasicBlock::Create(ctx, "repeat.exit", fn);
+        llvm::Function* fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock* body_bb = llvm::BasicBlock::Create(ctx, "repeat.body", fn);
+        llvm::BasicBlock* latch = llvm::BasicBlock::Create(ctx, "repeat.cond", fn);
+        llvm::BasicBlock* exit_bb = llvm::BasicBlock::Create(ctx, "repeat.exit", fn);
 
-        llvm::Value *mark = frame_mark();
+        llvm::Value* mark = frame_mark();
         builder.CreateBr(body_bb);
 
         builder.SetInsertPoint(body_bb);
@@ -417,9 +397,9 @@ class CodeGen {
         }
 
         builder.SetInsertPoint(latch);
-        llvm::Value *cond = gen(child[0]);
+        llvm::Value* cond = gen(child[0]);
         if (cond == nullptr) return nullptr;
-        llvm::Value *again = builder.CreateICmpEQ(as_int(cond), builder.getInt64(0));
+        llvm::Value* again = builder.CreateICmpEQ(as_int(cond), builder.getInt64(0));
         frame_release(mark);
         builder.CreateCondBr(again, body_bb, exit_bb);
 
@@ -428,38 +408,36 @@ class CodeGen {
         return make_none();
     }
 
-    llvm::Value *gen_for(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_for(const std::shared_ptr<Node>& node) {
         NodeList child = node->get_child();
         // Evaluation order matches visit_for: assign, step (default 1), end.
-        llvm::Value *init = gen(child[0]);
+        llvm::Value* init = gen(child[0]);
         if (init == nullptr) return nullptr;
-        llvm::Value *step = child[2] != nullptr ? gen(child[2]) : make_int(1);
+        llvm::Value* step = child[2] != nullptr ? gen(child[2]) : make_int(1);
         if (step == nullptr) return nullptr;
-        llvm::Value *end = gen(child[1]);
+        llvm::Value* end = gen(child[1]);
         if (end == nullptr) return nullptr;
-        builder.CreateCall(get_rt("rt_for_step_check", builder.getVoidTy(),
-                                  {ptr_ty}),
-                           {step});
+        builder.CreateCall(get_rt("rt_for_step_check", builder.getVoidTy(), {ptr_ty}), {step});
 
         const std::string var_name = child[0]->get_name();
-        llvm::AllocaInst *slot = entry_alloca(ptr_ty);
+        llvm::AllocaInst* slot = entry_alloca(ptr_ty);
         builder.CreateStore(init, slot);
 
         // Dedicated frame keeping the latest loop-variable value alive even if
         // the body rebinds the variable (the interpreter holds it in a local).
-        llvm::Value *var_frame = frame_mark();
+        llvm::Value* var_frame = frame_mark();
         frame_push();
-        llvm::Value *iter_mark = frame_mark();
+        llvm::Value* iter_mark = frame_mark();
 
-        llvm::Function *fn = builder.GetInsertBlock()->getParent();
-        llvm::BasicBlock *header = llvm::BasicBlock::Create(ctx, "for.cond", fn);
-        llvm::BasicBlock *body_bb = llvm::BasicBlock::Create(ctx, "for.body", fn);
-        llvm::BasicBlock *latch = llvm::BasicBlock::Create(ctx, "for.latch", fn);
-        llvm::BasicBlock *exit_bb = llvm::BasicBlock::Create(ctx, "for.exit", fn);
+        llvm::Function* fn = builder.GetInsertBlock()->getParent();
+        llvm::BasicBlock* header = llvm::BasicBlock::Create(ctx, "for.cond", fn);
+        llvm::BasicBlock* body_bb = llvm::BasicBlock::Create(ctx, "for.body", fn);
+        llvm::BasicBlock* latch = llvm::BasicBlock::Create(ctx, "for.latch", fn);
+        llvm::BasicBlock* exit_bb = llvm::BasicBlock::Create(ctx, "for.exit", fn);
         builder.CreateBr(header);
 
         builder.SetInsertPoint(header);
-        llvm::Value *keep_going = builder.CreateICmpNE(
+        llvm::Value* keep_going = builder.CreateICmpNE(
             builder.CreateCall(get_rt("rt_for_cond", i64_ty, {ptr_ty, ptr_ty, ptr_ty}),
                                {builder.CreateLoad(ptr_ty, slot), end, step}),
             builder.getInt64(0));
@@ -478,13 +456,12 @@ class CodeGen {
         // Latch mirrors visit_for: the next value comes from the value read at
         // the previous latch, not from body reassignments of the variable.
         builder.SetInsertPoint(latch);
-        llvm::Value *next = builder.CreateCall(
+        llvm::Value* next = builder.CreateCall(
             get_rt("rt_bin_op", ptr_ty, {i64_ty, ptr_ty, ptr_ty}),
             {builder.getInt64(RT_OP_ADD), builder.CreateLoad(ptr_ty, slot), step});
         builder.CreateCall(get_rt("rt_set_var", ptr_ty, {ptr_ty, ptr_ty}),
                            {cstring(var_name), next});
-        builder.CreateCall(get_rt("rt_loop_keep", builder.getVoidTy(),
-                                  {i64_ty, ptr_ty}),
+        builder.CreateCall(get_rt("rt_loop_keep", builder.getVoidTy(), {i64_ty, ptr_ty}),
                            {var_frame, next});
         builder.CreateStore(next, slot);
         frame_release(iter_mark);
@@ -497,8 +474,8 @@ class CodeGen {
 
     // Emits a loop body (one or more statements). Returns true when the body
     // terminated the current block (break/continue/return on every path).
-    bool gen_body(const NodeList &body) {
-        for (const auto &stmt : body) {
+    bool gen_body(const NodeList& body) {
+        for (const auto& stmt : body) {
             if (gen(stmt) == nullptr) {
                 return block_terminated() || !errors.empty();
             }
@@ -506,15 +483,14 @@ class CodeGen {
         return false;
     }
 
-    llvm::Value *gen_loop_jump(const std::shared_ptr<Node> &node, bool is_break) {
+    llvm::Value* gen_loop_jump(const std::shared_ptr<Node>& node, bool is_break) {
         if (loops.empty()) {
-            error(std::string("compile error: ") +
-                      (is_break ? "break" : "continue") +
+            error(std::string("compile error: ") + (is_break ? "break" : "continue") +
                       " outside of a loop is not supported by the compiler",
                   node);
             return nullptr;
         }
-        const LoopContext &loop = loops.back();
+        const LoopContext& loop = loops.back();
         if (is_break) {
             frame_release(loop.iter_mark);
             builder.CreateBr(loop.exit);
@@ -527,10 +503,10 @@ class CodeGen {
         return nullptr;
     }
 
-    llvm::Value *gen_return(const std::shared_ptr<Node> &node) {
-        llvm::Value *value = gen(node->get_child()[0]);
+    llvm::Value* gen_return(const std::shared_ptr<Node>& node) {
+        llvm::Value* value = gen(node->get_child()[0]);
         if (value == nullptr) return nullptr;
-        llvm::Function *fn = builder.GetInsertBlock()->getParent();
+        llvm::Function* fn = builder.GetInsertBlock()->getParent();
         if (fn->getName() == "main") {
             // Top-level `return` does not stop execution in the interpreter.
             return value;
@@ -541,21 +517,20 @@ class CodeGen {
 
     /// ---- functions and calls ----
 
-    llvm::Value *gen_algo_def(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_algo_def(const std::shared_ptr<Node>& node) {
         const std::string name = node->get_name();
         if (name.find("::") != std::string::npos) {
-            error("compile error: Struct is not supported by the compiler yet",
-                  node);
+            error("compile error: Struct is not supported by the compiler yet", node);
             return nullptr;
         }
 
-        AlgorithmDefNode *def = dynamic_cast<AlgorithmDefNode *>(node.get());
+        AlgorithmDefNode* def = dynamic_cast<AlgorithmDefNode*>(node.get());
         std::vector<std::string> arg_names;
-        for (const auto &tok : node->get_toks()) {
+        for (const auto& tok : node->get_toks()) {
             arg_names.push_back(tok->get_value());
         }
 
-        llvm::Function *fn = llvm::Function::Create(
+        llvm::Function* fn = llvm::Function::Create(
             llvm::FunctionType::get(ptr_ty, false), llvm::Function::PrivateLinkage,
             "ps.algo." + std::to_string(algo_counter++) + "." + name, module);
 
@@ -563,9 +538,9 @@ class CodeGen {
         std::vector<LoopContext> saved_loops;
         saved_loops.swap(loops);
 
-        llvm::BasicBlock *entry = llvm::BasicBlock::Create(ctx, "entry", fn);
+        llvm::BasicBlock* entry = llvm::BasicBlock::Create(ctx, "entry", fn);
         builder.SetInsertPoint(entry);
-        llvm::Value *last = gen_statements(def->get_body());
+        llvm::Value* last = gen_statements(def->get_body());
         if (!block_terminated() && errors.empty()) {
             builder.CreateRet(last != nullptr ? last : make_none());
         }
@@ -577,24 +552,26 @@ class CodeGen {
         }
 
         // Registration happens at the definition site, like visit_algo_def.
-        llvm::ArrayType *names_ty = llvm::ArrayType::get(ptr_ty, arg_names.size());
-        std::vector<llvm::Constant *> name_ptrs;
-        for (const auto &arg : arg_names) {
+        llvm::ArrayType* names_ty = llvm::ArrayType::get(ptr_ty, arg_names.size());
+        std::vector<llvm::Constant*> name_ptrs;
+        for (const auto& arg : arg_names) {
             name_ptrs.push_back(llvm::cast<llvm::Constant>(cstring(arg)));
         }
-        auto *names_global = new llvm::GlobalVariable(
-            module, names_ty, true, llvm::GlobalValue::PrivateLinkage,
-            llvm::ConstantArray::get(names_ty, name_ptrs), "args");
+        auto* names_global =
+            new llvm::GlobalVariable(module, names_ty, true, llvm::GlobalValue::PrivateLinkage,
+                                     llvm::ConstantArray::get(names_ty, name_ptrs), "args");
+        const bool memoizable = is_memoizable_numeric_algo(node, name, arg_names);
         return builder.CreateCall(
-            get_rt("rt_define_algo", ptr_ty, {ptr_ty, ptr_ty, ptr_ty, i64_ty}),
+            get_rt("rt_define_algo", ptr_ty, {ptr_ty, ptr_ty, ptr_ty, i64_ty, i64_ty}),
             {cstring(name), fn, names_global,
-             builder.getInt64(static_cast<int64_t>(arg_names.size()))});
+             builder.getInt64(static_cast<int64_t>(arg_names.size())),
+             builder.getInt64(memoizable ? 1 : 0)});
     }
 
-    llvm::Value *gen_algo_call(const std::shared_ptr<Node> &node) {
-        AlgorithmCallNode *call = dynamic_cast<AlgorithmCallNode *>(node.get());
+    llvm::Value* gen_algo_call(const std::shared_ptr<Node>& node) {
+        AlgorithmCallNode* call = dynamic_cast<AlgorithmCallNode*>(node.get());
         std::shared_ptr<Node> callee_node = call->get_call();
-        llvm::Value *callee;
+        llvm::Value* callee;
         if (callee_node->get_type() == NODE_VARACCESS) {
             callee = gen_var_access(callee_node);
         } else {
@@ -602,20 +579,19 @@ class CodeGen {
         }
         if (callee == nullptr) return nullptr;
 
-        const NodeList &args = call->get_args();
-        llvm::Value *argv;
+        const NodeList& args = call->get_args();
+        llvm::Value* argv;
         if (args.empty()) {
             argv = llvm::ConstantPointerNull::get(ptr_ty);
         } else {
-            llvm::ArrayType *argv_ty = llvm::ArrayType::get(ptr_ty, args.size());
-            llvm::Function *fn = builder.GetInsertBlock()->getParent();
+            llvm::ArrayType* argv_ty = llvm::ArrayType::get(ptr_ty, args.size());
+            llvm::Function* fn = builder.GetInsertBlock()->getParent();
             llvm::IRBuilder<> tmp(&fn->getEntryBlock(), fn->getEntryBlock().begin());
-            llvm::AllocaInst *slots = tmp.CreateAlloca(argv_ty);
+            llvm::AllocaInst* slots = tmp.CreateAlloca(argv_ty);
             for (size_t i = 0; i < args.size(); ++i) {
-                llvm::Value *arg = gen(args[i]);
+                llvm::Value* arg = gen(args[i]);
                 if (arg == nullptr) return nullptr;
-                builder.CreateStore(
-                    arg, builder.CreateConstInBoundsGEP2_64(argv_ty, slots, 0, i));
+                builder.CreateStore(arg, builder.CreateConstInBoundsGEP2_64(argv_ty, slots, 0, i));
             }
             argv = slots;
         }
@@ -626,72 +602,68 @@ class CodeGen {
 
     /// ---- arrays, hash tables, members ----
 
-    llvm::Value *gen_array(const std::shared_ptr<Node> &node) {
-        llvm::Value *array = builder.CreateCall(get_rt("rt_array_new", ptr_ty, {}));
-        for (const auto &element : node->get_child()) {
-            llvm::Value *value = gen(element);
+    llvm::Value* gen_array(const std::shared_ptr<Node>& node) {
+        llvm::Value* array = builder.CreateCall(get_rt("rt_array_new", ptr_ty, {}));
+        for (const auto& element : node->get_child()) {
+            llvm::Value* value = gen(element);
             if (value == nullptr) return nullptr;
-            builder.CreateCall(get_rt("rt_array_push", builder.getVoidTy(),
-                                      {ptr_ty, ptr_ty}),
+            builder.CreateCall(get_rt("rt_array_push", builder.getVoidTy(), {ptr_ty, ptr_ty}),
                                {array, value});
         }
         return array;
     }
 
-    llvm::Value *gen_array_access(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_array_access(const std::shared_ptr<Node>& node) {
         NodeList child = node->get_child();
-        llvm::Value *container = gen(child[0]);
+        llvm::Value* container = gen(child[0]);
         if (container == nullptr) return nullptr;
-        llvm::Value *index = gen(child[1]);
+        llvm::Value* index = gen(child[1]);
         if (index == nullptr) return nullptr;
-        return builder.CreateCall(get_rt("rt_index", ptr_ty, {ptr_ty, ptr_ty}),
-                                  {container, index});
+        return builder.CreateCall(get_rt("rt_index", ptr_ty, {ptr_ty, ptr_ty}), {container, index});
     }
 
-    llvm::Value *gen_array_assign(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_array_assign(const std::shared_ptr<Node>& node) {
         NodeList child = node->get_child();
         if (child[0]->get_type() == NODE_MEMACCESS) {
             NodeList member_child = child[0]->get_child();
-            llvm::Value *object = gen(member_child[0]);
+            llvm::Value* object = gen(member_child[0]);
             if (object == nullptr) return nullptr;
-            llvm::Value *value = gen(child[1]);
+            llvm::Value* value = gen(child[1]);
             if (value == nullptr) return nullptr;
-            return builder.CreateCall(
-                get_rt("rt_member_assign", ptr_ty, {ptr_ty, ptr_ty, ptr_ty}),
-                {object, cstring(member_child[1]->get_name()), value});
+            return builder.CreateCall(get_rt("rt_member_assign", ptr_ty, {ptr_ty, ptr_ty, ptr_ty}),
+                                      {object, cstring(member_child[1]->get_name()), value});
         }
         if (child[0]->get_type() != NODE_ARRACCESS) {
-            error("compile error: assignment target must be an array element or "
-                  "object member",
-                  node);
+            error(
+                "compile error: assignment target must be an array element or "
+                "object member",
+                node);
             return nullptr;
         }
         NodeList access_child = child[0]->get_child();
-        llvm::Value *container = gen(access_child[0]);
+        llvm::Value* container = gen(access_child[0]);
         if (container == nullptr) return nullptr;
-        llvm::Value *index = gen(access_child[1]);
+        llvm::Value* index = gen(access_child[1]);
         if (index == nullptr) return nullptr;
-        llvm::Value *value = gen(child[1]);
+        llvm::Value* value = gen(child[1]);
         if (value == nullptr) return nullptr;
-        return builder.CreateCall(
-            get_rt("rt_index_assign", ptr_ty, {ptr_ty, ptr_ty, ptr_ty}),
-            {container, index, value});
+        return builder.CreateCall(get_rt("rt_index_assign", ptr_ty, {ptr_ty, ptr_ty, ptr_ty}),
+                                  {container, index, value});
     }
 
-    llvm::Value *gen_member_access(const std::shared_ptr<Node> &node) {
+    llvm::Value* gen_member_access(const std::shared_ptr<Node>& node) {
         NodeList child = node->get_child();
-        llvm::Value *object = gen(child[0]);
+        llvm::Value* object = gen(child[0]);
         if (object == nullptr) return nullptr;
-        return builder.CreateCall(
-            get_rt("rt_member_access", ptr_ty, {ptr_ty, ptr_ty}),
-            {object, cstring(child[1]->get_name())});
+        return builder.CreateCall(get_rt("rt_member_access", ptr_ty, {ptr_ty, ptr_ty}),
+                                  {object, cstring(child[1]->get_name())});
     }
 };
 
-} // namespace
+}  // namespace
 
-bool Compiler::compile(const NodeList &ast, llvm::Module &module,
-                       std::vector<std::string> &errors) {
+bool Compiler::compile(const NodeList& ast, llvm::Module& module,
+                       std::vector<std::string>& errors) {
     CodeGen codegen(module, errors);
     return codegen.run(ast);
 }
diff --git a/src/compiler.h b/src/compiler.h
index f6b9488..829a9ff 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -5,21 +5,22 @@
 #ifndef COMPILER_H
 #define COMPILER_H
 
-#include "node.h"
 #include <string>
 #include <vector>
 
+#include "node.h"
+
 namespace llvm {
 class Module;
-} // namespace llvm
+}  // namespace llvm
 
 class Compiler {
-public:
+   public:
     // Lowers the parsed program into `module` (a `main` function plus one
     // function per Algorithm). Returns false and fills `errors` when the
     // program uses features the compiler does not support.
-    static bool compile(const NodeList &ast, llvm::Module &module,
-                        std::vector<std::string> &errors);
+    static bool compile(const NodeList& ast, llvm::Module& module,
+                        std::vector<std::string>& errors);
 };
 
 #endif
diff --git a/src/imports.h b/src/imports.h
index 2f109d4..32e1bbf 100644
--- a/src/imports.h
+++ b/src/imports.h
@@ -16,8 +16,7 @@ struct ImportState {
 // Recursively replaces `import` lines in `text` with the imported file
 // contents. Returns false and fills `error` on unresolved, unreadable, or
 // circular imports.
-bool expand_imports(const std::string &file_name, const std::string &text,
-                    ImportState &state, std::string &expanded,
-                    std::string &error);
+bool expand_imports(const std::string& file_name, const std::string& text, ImportState& state,
+                    std::string& expanded, std::string& error);
 
 #endif
diff --git a/src/pseudo.cpp b/src/pseudo.cpp
index 7e64ed8..b4ff492 100644
--- a/src/pseudo.cpp
+++ b/src/pseudo.cpp
@@ -1,4 +1,5 @@
 #include "pseudo.h"
+#include "analysis.h"
 #include "imports.h"
 #include "color.h"
 #include "interpreter.h"
@@ -401,6 +402,8 @@ bool has_self_call(const std::shared_ptr<Node>& node, const std::string& algo_na
   return false;
 }
 
+} // namespace
+
 bool is_memoizable_numeric_algo(const std::shared_ptr<Node>& node,
                                 const std::string& algo_name,
                                 const std::vector<std::string>& args) {
@@ -418,6 +421,8 @@ bool is_memoizable_numeric_algo(const std::shared_ptr<Node>& node,
   return recursive;
 }
 
+namespace {
+
 std::shared_ptr<Node> single_return_numeric_expr(const std::shared_ptr<Node>& node,
                                                  const std::string& algo_name,
                                                  const std::vector<std::string>& args) {
diff --git a/src/pseudoc.cpp b/src/pseudoc.cpp
index b5cec10..9c1bd2c 100644
--- a/src/pseudoc.cpp
+++ b/src/pseudoc.cpp
@@ -5,14 +5,6 @@
 /// Compiles a .ps source file to a native executable:
 ///   pseudoc <file.ps> [-o <out>] [--emit-llvm] [--runtime-lib <path>]
 
-#include "compiler.h"
-#include "error.h"
-#include "imports.h"
-#include "lexer.h"
-#include "node.h"
-#include "parser.h"
-#include "token.h"
-
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/LegacyPassManager.h>
 #include <llvm/IR/Module.h>
@@ -25,16 +17,24 @@
 #include <llvm/Target/TargetMachine.h>
 #include <llvm/TargetParser/Host.h>
 #include <llvm/TargetParser/Triple.h>
+#include <unistd.h>
 
 #include <cstdlib>
 #include <filesystem>
-#include <unistd.h>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "compiler.h"
+#include "error.h"
+#include "imports.h"
+#include "lexer.h"
+#include "node.h"
+#include "parser.h"
+#include "token.h"
+
 namespace {
 
 namespace fs = std::filesystem;
@@ -44,12 +44,12 @@ void usage() {
                  "[--runtime-lib <path>]\n";
 }
 
-std::string find_runtime_lib(const std::string &flag_value, const char *argv0) {
+std::string find_runtime_lib(const std::string& flag_value, const char* argv0) {
     std::vector<fs::path> candidates;
     if (!flag_value.empty()) {
         candidates.emplace_back(flag_value);
     }
-    if (const char *env = std::getenv("PSEUDO_RT_LIB")) {
+    if (const char* env = std::getenv("PSEUDO_RT_LIB")) {
         candidates.emplace_back(env);
     }
     std::error_code ec;
@@ -59,7 +59,7 @@ std::string find_runtime_lib(const std::string &flag_value, const char *argv0) {
     }
     candidates.push_back(fs::current_path() / "build" / "libpseudort.a");
 
-    for (const auto &candidate : candidates) {
+    for (const auto& candidate : candidates) {
         if (fs::exists(candidate, ec) && fs::is_regular_file(candidate, ec)) {
             return candidate.string();
         }
@@ -67,7 +67,7 @@ std::string find_runtime_lib(const std::string &flag_value, const char *argv0) {
     return "";
 }
 
-std::string shell_quote(const std::string &text) {
+std::string shell_quote(const std::string& text) {
     std::string quoted = "'";
     for (char c : text) {
         if (c == '\'') {
@@ -80,9 +80,9 @@ std::string shell_quote(const std::string &text) {
     return quoted;
 }
 
-} // namespace
+}  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
     std::string input_path, output_path, runtime_lib_flag;
     bool emit_llvm = false;
     for (int i = 1; i < argc; ++i) {
@@ -130,36 +130,32 @@ int main(int argc, char **argv) {
 
     ImportState import_state;
     std::string expanded_text, import_error;
-    if (!expand_imports(input_path, code, import_state, expanded_text,
-                        import_error)) {
+    if (!expand_imports(input_path, code, import_state, expanded_text, import_error)) {
         std::cout << import_error << "\n";
         return 1;
     }
 
     Lexer lexer(input_path, expanded_text);
     TokenList tokens = lexer.make_tokens();
-    for (const auto &tok : tokens) {
+    for (const auto& tok : tokens) {
         if (tok->get_type() == TOKEN_ERROR) {
-            std::cout << "Error: " << tok->get_value() << ", line "
-                      << tok->get_pos().line + 1
+            std::cout << "Error: " << tok->get_value() << ", line " << tok->get_pos().line + 1
                       << ", column: " << tok->get_pos().column << "\n";
-            std::cout << error_marker(expanded_text, tok->get_pos(),
-                                      tok->get_pos());
+            std::cout << error_marker(expanded_text, tok->get_pos(), tok->get_pos());
             return 1;
         }
     }
 
     Parser parser(tokens);
     NodeList ast = parser.parse();
-    for (const auto &node : ast) {
+    for (const auto& node : ast) {
         if (node->get_type() == NODE_ERROR) {
             std::shared_ptr<Token> err_tok = node->get_tok();
             if (err_tok) {
                 std::cout << "Error: " << err_tok->get_value() << ", line "
                           << err_tok->get_pos().line + 1
                           << ", column: " << err_tok->get_pos().column << "\n";
-                std::cout << error_marker(expanded_text, err_tok->get_pos(),
-                                          err_tok->get_pos());
+                std::cout << error_marker(expanded_text, err_tok->get_pos(), err_tok->get_pos());
             } else {
                 std::cout << "Error: " << node->get_node() << "\n";
             }
@@ -171,7 +167,7 @@ int main(int argc, char **argv) {
     llvm::Module module(input_path, context);
     std::vector<std::string> compile_errors;
     if (!Compiler::compile(ast, module, compile_errors)) {
-        for (const auto &message : compile_errors) {
+        for (const auto& message : compile_errors) {
             std::cout << message << "\n";
         }
         return 1;
@@ -193,16 +189,14 @@ int main(int argc, char **argv) {
 
     std::string triple_name = llvm::sys::getDefaultTargetTriple();
     std::string lookup_error;
-    const llvm::Target *target =
-        llvm::TargetRegistry::lookupTarget(triple_name, lookup_error);
+    const llvm::Target* target = llvm::TargetRegistry::lookupTarget(triple_name, lookup_error);
     if (target == nullptr) {
         std::cout << "target lookup failed: " << lookup_error << "\n";
         return 1;
     }
     llvm::TargetOptions target_options;
-    llvm::TargetMachine *machine = target->createTargetMachine(
-        llvm::Triple(triple_name), "generic", "", target_options,
-        llvm::Reloc::PIC_);
+    llvm::TargetMachine* machine = target->createTargetMachine(
+        llvm::Triple(triple_name), "generic", "", target_options, llvm::Reloc::PIC_);
     module.setDataLayout(machine->createDataLayout());
     module.setTargetTriple(llvm::Triple(triple_name));
 
@@ -222,15 +216,12 @@ int main(int argc, char **argv) {
     mpm.run(module, mam);
 
     fs::path object_path =
-        fs::temp_directory_path() /
-        ("pseudoc-" + std::to_string(::getpid()) + ".o");
+        fs::temp_directory_path() / ("pseudoc-" + std::to_string(::getpid()) + ".o");
     {
         std::error_code ec;
-        llvm::raw_fd_ostream object_stream(object_path.string(), ec,
-                                           llvm::sys::fs::OF_None);
+        llvm::raw_fd_ostream object_stream(object_path.string(), ec, llvm::sys::fs::OF_None);
         if (ec) {
-            std::cout << "cannot write " << object_path.string() << ": "
-                      << ec.message() << "\n";
+            std::cout << "cannot write " << object_path.string() << ": " << ec.message() << "\n";
             return 1;
         }
         llvm::legacy::PassManager emit_pm;
@@ -251,12 +242,11 @@ int main(int argc, char **argv) {
     }
 
     std::string linker = "c++";
-    if (const char *env = std::getenv("PSEUDO_LD")) {
+    if (const char* env = std::getenv("PSEUDO_LD")) {
         linker = env;
     }
-    std::string command = linker + " " + shell_quote(object_path.string()) +
-                          " " + shell_quote(runtime_lib) + " -o " +
-                          shell_quote(output_path);
+    std::string command = linker + " " + shell_quote(object_path.string()) + " " +
+                          shell_quote(runtime_lib) + " -o " + shell_quote(output_path);
     int status = std::system(command.c_str());
     fs::remove(object_path);
     if (status != 0) {
diff --git a/src/runtime.cpp b/src/runtime.cpp
index 51cb52c..fc67757 100644
--- a/src/runtime.cpp
+++ b/src/runtime.cpp
@@ -3,17 +3,20 @@
 /// --------------------
 
 #include "runtime.h"
-#include "color.h"
-#include "interpreter.h"
-#include "node.h"
-#include "symboltable.h"
-#include "value.h"
+
 #include <cstdlib>
 #include <iostream>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
+#include "color.h"
+#include "interpreter.h"
+#include "node.h"
+#include "symboltable.h"
+#include "value.h"
+
 namespace {
 
 // Arena frames keep every runtime-created value alive until its frame is
@@ -23,12 +26,12 @@ std::vector<std::vector<std::shared_ptr<Value>>> frames;
 // globals. Parents follow the caller chain, like the interpreter.
 std::vector<std::unique_ptr<SymbolTable>> scopes;
 
-[[noreturn]] void rt_fail(const std::shared_ptr<Value> &err) {
+[[noreturn]] void rt_fail(const std::shared_ptr<Value>& err) {
     std::cout << err->get_num() << "\n";
     exit(1);
 }
 
-Value *track(std::shared_ptr<Value> value) {
+Value* track(std::shared_ptr<Value> value) {
     if (value->get_type() == VALUE_ERROR) {
         rt_fail(value);
     }
@@ -36,30 +39,48 @@ Value *track(std::shared_ptr<Value> value) {
     return value.get();
 }
 
-std::shared_ptr<Value> ref(Value *v) { return v->shared_from_this(); }
+std::shared_ptr<Value> ref(Value* v) { return v->shared_from_this(); }
 
-SymbolTable &current_scope() { return *scopes.back(); }
+SymbolTable& current_scope() { return *scopes.back(); }
 
 class CompiledAlgoValue : public Value {
-public:
-    CompiledAlgoValue(const std::string &_algo_name, Value *(*_fn)(),
-                      std::vector<std::string> _arg_names)
-        : Value(VALUE_ALGO), fn(_fn), algo_name(_algo_name),
-          arg_names(std::move(_arg_names)) {}
+   public:
+    CompiledAlgoValue(const std::string& _algo_name, Value* (*_fn)(),
+                      std::vector<std::string> _arg_names, bool _memoizable)
+        : Value(VALUE_ALGO),
+          fn(_fn),
+          algo_name(_algo_name),
+          arg_names(std::move(_arg_names)),
+          memoizable(_memoizable) {}
 
     std::string get_num() override { return algo_name; }
     std::string repr() override { return algo_name; }
 
-    std::shared_ptr<Value> execute(const NodeList &args = {},
-                                   SymbolTable *parent = nullptr) override;
+    std::shared_ptr<Value> execute(const NodeList& args = {},
+                                   SymbolTable* parent = nullptr) override;
 
-    Value *(*fn)();
+    Value* (*fn)();
     std::string algo_name;
     std::vector<std::string> arg_names;
+    bool memoizable;
+    std::unordered_map<std::string, std::shared_ptr<Value>> memo;
 };
 
-std::shared_ptr<Value> call_compiled(CompiledAlgoValue *algo,
-                                     const ValueList &args) {
+// Mirrors numeric_cache_key in pseudo.cpp; empty when any argument is not a
+// plain number.
+std::string numeric_args_key(const ValueList& values) {
+    std::string key;
+    for (const auto& value : values) {
+        if (value->get_type() != VALUE_INT && value->get_type() != VALUE_FLOAT) return "";
+        key += value->get_type();
+        key += ':';
+        key += value->get_num();
+        key += '|';
+    }
+    return key;
+}
+
+std::shared_ptr<Value> call_compiled(CompiledAlgoValue* algo, const ValueList& args) {
     if (args.size() < algo->arg_names.size()) {
         return std::make_shared<ErrorValue>(
             VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too few arguments" RESET);
@@ -69,26 +90,39 @@ std::shared_ptr<Value> call_compiled(CompiledAlgoValue *algo,
             VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too many arguments" RESET);
     }
 
+    std::string memo_key;
+    if (algo->memoizable) {
+        memo_key = numeric_args_key(args);
+        if (!memo_key.empty()) {
+            auto cached = algo->memo.find(memo_key);
+            if (cached != algo->memo.end()) {
+                return cached->second;
+            }
+        }
+    }
+
     int64_t mark = rt_frame_mark();
     rt_frame_push();
     scopes.push_back(std::make_unique<SymbolTable>(&current_scope()));
     for (size_t i = 0; i < args.size(); ++i) {
         scopes.back()->set(algo->arg_names[i], args[i]);
     }
-    Value *result = algo->fn();
+    Value* result = algo->fn();
     std::shared_ptr<Value> kept = ref(result);
     scopes.pop_back();
     rt_frame_release(mark);
+    if (!memo_key.empty() && (kept->get_type() == VALUE_INT || kept->get_type() == VALUE_FLOAT)) {
+        algo->memo[memo_key] = kept;
+    }
     return kept;
 }
 
-std::shared_ptr<Value> CompiledAlgoValue::execute(const NodeList &args,
-                                                  SymbolTable *parent) {
+std::shared_ptr<Value> CompiledAlgoValue::execute(const NodeList& args, SymbolTable* parent) {
     SymbolTable sym(parent);
     Interpreter interpreter(sym);
     ValueList evaluated;
     evaluated.reserve(args.size());
-    for (const auto &arg : args) {
+    for (const auto& arg : args) {
         std::shared_ptr<Value> v = interpreter.visit(arg);
         if (v->get_type() == VALUE_ERROR) {
             return v;
@@ -98,7 +132,7 @@ std::shared_ptr<Value> CompiledAlgoValue::execute(const NodeList &args,
     return call_compiled(this, evaluated);
 }
 
-} // namespace
+}  // namespace
 
 extern "C" {
 
@@ -107,76 +141,82 @@ void rt_init() {
     scopes.push_back(std::make_unique<SymbolTable>());
 }
 
-Value *rt_make_int(int64_t v) {
-    return track(std::make_shared<TypedValue<int64_t>>(VALUE_INT, v));
-}
+Value* rt_make_int(int64_t v) { return track(std::make_shared<TypedValue<int64_t>>(VALUE_INT, v)); }
 
-Value *rt_make_float(double v) {
+Value* rt_make_float(double v) {
     return track(std::make_shared<TypedValue<double>>(VALUE_FLOAT, v));
 }
 
-Value *rt_make_string(const char *s) {
-    return track(
-        std::make_shared<TypedValue<std::string>>(VALUE_STRING, std::string(s)));
+Value* rt_make_string(const char* s) {
+    return track(std::make_shared<TypedValue<std::string>>(VALUE_STRING, std::string(s)));
 }
 
-Value *rt_make_none() { return track(std::make_shared<Value>()); }
+Value* rt_make_none() { return track(std::make_shared<Value>()); }
 
-Value *rt_array_new() {
-    return track(std::make_shared<ArrayValue>(ValueList(0)));
-}
+Value* rt_array_new() { return track(std::make_shared<ArrayValue>(ValueList(0))); }
 
-void rt_array_push(Value *arr, Value *v) {
-    dynamic_cast<ArrayValue *>(arr)->push_back(ref(v));
-}
+void rt_array_push(Value* arr, Value* v) { dynamic_cast<ArrayValue*>(arr)->push_back(ref(v)); }
 
-Value *rt_get_var(const char *name) {
-    return track(current_scope().get(name));
-}
+Value* rt_get_var(const char* name) { return track(current_scope().get(name)); }
 
-Value *rt_set_var(const char *name, Value *v) {
+Value* rt_set_var(const char* name, Value* v) {
     current_scope().set(name, ref(v));
     return track(current_scope().get(name));
 }
 
-Value *rt_bin_op(int64_t op, Value *a, Value *b) {
+Value* rt_bin_op(int64_t op, Value* a, Value* b) {
     std::shared_ptr<Value> lhs = ref(a), rhs = ref(b);
     switch (op) {
-    case RT_OP_ADD: return track(lhs + rhs);
-    case RT_OP_SUB: return track(lhs - rhs);
-    case RT_OP_MUL: return track(lhs * rhs);
-    case RT_OP_DIV: return track(lhs / rhs);
-    case RT_OP_MOD: return track(lhs % rhs);
-    case RT_OP_POW: return track(pow(lhs, rhs));
-    case RT_OP_EQUAL: return track(lhs == rhs);
-    case RT_OP_NEQ: return track(lhs != rhs);
-    case RT_OP_LESS: return track(lhs < rhs);
-    case RT_OP_GREATER: return track(lhs > rhs);
-    case RT_OP_LEQ: return track(lhs <= rhs);
-    case RT_OP_GEQ: return track(lhs >= rhs);
-    default:
-        rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Not a binary op\n"));
+        case RT_OP_ADD:
+            return track(lhs + rhs);
+        case RT_OP_SUB:
+            return track(lhs - rhs);
+        case RT_OP_MUL:
+            return track(lhs * rhs);
+        case RT_OP_DIV:
+            return track(lhs / rhs);
+        case RT_OP_MOD:
+            return track(lhs % rhs);
+        case RT_OP_POW:
+            return track(pow(lhs, rhs));
+        case RT_OP_EQUAL:
+            return track(lhs == rhs);
+        case RT_OP_NEQ:
+            return track(lhs != rhs);
+        case RT_OP_LESS:
+            return track(lhs < rhs);
+        case RT_OP_GREATER:
+            return track(lhs > rhs);
+        case RT_OP_LEQ:
+            return track(lhs <= rhs);
+        case RT_OP_GEQ:
+            return track(lhs >= rhs);
+        default:
+            rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Not a binary op\n"));
     }
 }
 
-Value *rt_unary_op(int64_t op, Value *a) {
+Value* rt_unary_op(int64_t op, Value* a) {
     std::shared_ptr<Value> operand = ref(a);
     switch (op) {
-    case RT_OP_UPLUS: return track(operand);
-    case RT_OP_UNEG: return track(-operand);
-    case RT_OP_UNOT: return track(!operand);
-    default:
-        rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Not an unary op\n"));
+        case RT_OP_UPLUS:
+            return track(operand);
+        case RT_OP_UNEG:
+            return track(-operand);
+        case RT_OP_UNOT:
+            return track(!operand);
+        default:
+            rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Not an unary op\n"));
     }
 }
 
-Value *rt_bool(Value *v) { return rt_make_int(v->as_int() != 0); }
+Value* rt_bool(Value* v) { return rt_make_int(v->as_int() != 0); }
 
-int64_t rt_cond_eq1(Value *v) { return std::stoll(v->get_num()) == 1; }
+int64_t rt_cond_eq1(Value* v) { return std::stoll(v->get_num()) == 1; }
 
-int64_t rt_as_int(Value *v) { return v->as_int(); }
+int64_t rt_as_int(Value* v) { return v->as_int(); }
 
-int64_t rt_for_cond(Value *i, Value *end, Value *step) {
+int64_t rt_for_cond(Value* i, Value* end, Value* step) {
     if (step->as_double() > 0) {
         if (i->get_type() == VALUE_FLOAT || end->get_type() == VALUE_FLOAT)
             return i->as_double() <= end->as_double();
@@ -187,42 +227,39 @@ int64_t rt_for_cond(Value *i, Value *end, Value *step) {
     return i->as_int() >= end->as_int();
 }
 
-void rt_for_step_check(Value *step) {
+void rt_for_step_check(Value* step) {
     if (step->as_double() == 0) {
         rt_fail(std::make_shared<ErrorValue>(VALUE_ERROR, "Infinite for loop\n"));
     }
 }
 
-Value *rt_index(Value *obj, Value *idx) {
+Value* rt_index(Value* obj, Value* idx) {
     std::shared_ptr<Value> container = ref(obj), index = ref(idx);
     if (container->get_type() == VALUE_STRING) {
         std::string str = container->as_string();
         int p = index->as_int();
         if (1 <= p && p <= static_cast<int>(str.size())) {
-            return track(std::make_shared<TypedValue<std::string>>(
-                VALUE_STRING, std::string(1, str[p - 1])));
+            return track(std::make_shared<TypedValue<std::string>>(VALUE_STRING,
+                                                                   std::string(1, str[p - 1])));
         }
         return track(std::make_shared<ErrorValue>(
             VALUE_ERROR, "Index out of range, size: " + std::to_string(str.size()) +
                              ", position: " + std::to_string(p)));
     }
     if (container->get_type() == VALUE_HASH_TABLE) {
-        return track(dynamic_cast<HashTableValue *>(container.get())->get(index));
+        return track(dynamic_cast<HashTableValue*>(container.get())->get(index));
     }
     if (container->get_type() != VALUE_ARRAY) {
         return track(std::make_shared<ErrorValue>(
-            VALUE_ERROR,
-            "Access can only apply on array, find " + container->get_type() + "\n"));
+            VALUE_ERROR, "Access can only apply on array, find " + container->get_type() + "\n"));
     }
-    return track(
-        dynamic_cast<ArrayValue *>(container.get())->operator[](index->as_int()));
+    return track(dynamic_cast<ArrayValue*>(container.get())->operator[](index->as_int()));
 }
 
-Value *rt_index_assign(Value *obj, Value *idx, Value *v) {
+Value* rt_index_assign(Value* obj, Value* idx, Value* v) {
     std::shared_ptr<Value> container = ref(obj), index = ref(idx), value = ref(v);
     if (container->get_type() == VALUE_HASH_TABLE) {
-        return track(
-            dynamic_cast<HashTableValue *>(container.get())->set(index, value));
+        return track(dynamic_cast<HashTableValue*>(container.get())->set(index, value));
     }
     if (container->get_type() != VALUE_ARRAY) {
         return track(std::make_shared<ErrorValue>(
@@ -230,57 +267,54 @@ Value *rt_index_assign(Value *obj, Value *idx, Value *v) {
     }
     // Matches visit_array_assign: an out-of-range index assigns into the
     // array's error slot and is effectively ignored.
-    dynamic_cast<ArrayValue *>(container.get())->operator[](index->as_int()) =
-        value;
+    dynamic_cast<ArrayValue*>(container.get())->operator[](index->as_int()) = value;
     return track(value);
 }
 
-Value *rt_member_access(Value *obj, const char *name) {
+Value* rt_member_access(Value* obj, const char* name) {
     std::shared_ptr<Value> object = ref(obj);
     if (object->get_type() == VALUE_ARRAY || object->get_type() == VALUE_STRING ||
         object->get_type() == VALUE_HASH_TABLE) {
         return track(std::make_shared<BoundMethodValue>(object, name));
     }
     if (object->get_type() == VALUE_INSTANCE) {
-        return track(dynamic_cast<InstanceValue *>(object.get())
-                         ->get_member(name, object));
+        return track(dynamic_cast<InstanceValue*>(object.get())->get_member(name, object));
     }
     return track(std::make_shared<ErrorValue>(
-        VALUE_ERROR,
-        object->get_num() + " has no member " + std::string(name) + "\n"));
+        VALUE_ERROR, object->get_num() + " has no member " + std::string(name) + "\n"));
 }
 
-Value *rt_member_assign(Value *obj, const char *name, Value *v) {
+Value* rt_member_assign(Value* obj, const char* name, Value* v) {
     std::shared_ptr<Value> object = ref(obj), value = ref(v);
     if (object->get_type() == VALUE_INSTANCE) {
-        dynamic_cast<InstanceValue *>(object.get())->set_member(name, value);
+        dynamic_cast<InstanceValue*>(object.get())->set_member(name, value);
         return track(value);
     }
     return track(std::make_shared<ErrorValue>(
         VALUE_ERROR, "Assignment to member only supported for Struct Instances\n"));
 }
 
-Value *rt_define_algo(const char *name, Value *(*fn)(),
-                      const char *const *arg_names, int64_t nargs) {
+Value* rt_define_algo(const char* name, Value* (*fn)(), const char* const* arg_names, int64_t nargs,
+                      int64_t memoizable) {
     std::vector<std::string> names;
     names.reserve(nargs);
     for (int64_t i = 0; i < nargs; ++i) {
         names.emplace_back(arg_names[i]);
     }
     std::shared_ptr<Value> algo =
-        std::make_shared<CompiledAlgoValue>(name, fn, std::move(names));
+        std::make_shared<CompiledAlgoValue>(name, fn, std::move(names), memoizable != 0);
     current_scope().set(name, algo);
     return track(algo);
 }
 
-Value *rt_call(Value *callee, Value **argv, int64_t argc) {
+Value* rt_call(Value* callee, Value** argv, int64_t argc) {
     ValueList args;
     args.reserve(argc);
     for (int64_t i = 0; i < argc; ++i) {
         args.push_back(ref(argv[i]));
     }
 
-    if (auto *compiled = dynamic_cast<CompiledAlgoValue *>(callee)) {
+    if (auto* compiled = dynamic_cast<CompiledAlgoValue*>(callee)) {
         return track(call_compiled(compiled, args));
     }
 
@@ -288,7 +322,7 @@ Value *rt_call(Value *callee, Value **argv, int64_t argc) {
     // over the already-evaluated arguments as precomputed AST nodes.
     NodeList arg_nodes;
     arg_nodes.reserve(argc);
-    for (const auto &arg : args) {
+    for (const auto& arg : args) {
         arg_nodes.push_back(std::make_shared<PrecomputedNode>(arg));
     }
     return track(callee->execute(arg_nodes, &current_scope()));
@@ -304,10 +338,10 @@ void rt_frame_release(int64_t mark) {
     }
 }
 
-void rt_loop_keep(int64_t frame_index, Value *v) {
+void rt_loop_keep(int64_t frame_index, Value* v) {
     std::shared_ptr<Value> kept = ref(v);
     frames[frame_index].clear();
     frames[frame_index].push_back(kept);
 }
 
-} // extern "C"
+}  // extern "C"
diff --git a/src/runtime.h b/src/runtime.h
index 45dff6a..d22d792 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -44,45 +44,47 @@ extern "C" {
 
 void rt_init();
 
-Value *rt_make_int(int64_t v);
-Value *rt_make_float(double v);
-Value *rt_make_string(const char *s);
-Value *rt_make_none();
-Value *rt_array_new();
-void rt_array_push(Value *arr, Value *v);
+Value* rt_make_int(int64_t v);
+Value* rt_make_float(double v);
+Value* rt_make_string(const char* s);
+Value* rt_make_none();
+Value* rt_array_new();
+void rt_array_push(Value* arr, Value* v);
 
-Value *rt_get_var(const char *name);
-Value *rt_set_var(const char *name, Value *v);
+Value* rt_get_var(const char* name);
+Value* rt_set_var(const char* name, Value* v);
 
-Value *rt_bin_op(int64_t op, Value *a, Value *b);
-Value *rt_unary_op(int64_t op, Value *a);
+Value* rt_bin_op(int64_t op, Value* a, Value* b);
+Value* rt_unary_op(int64_t op, Value* a);
 // Int 0/1 value from as_int() != 0 (used by short-circuit and/or).
-Value *rt_bool(Value *v);
+Value* rt_bool(Value* v);
 
 // stoll(get_num()) == 1, the interpreter's `if` condition.
-int64_t rt_cond_eq1(Value *v);
+int64_t rt_cond_eq1(Value* v);
 // as_int(), the interpreter's `while` / `repeat` condition.
-int64_t rt_as_int(Value *v);
+int64_t rt_as_int(Value* v);
 // Float-aware inclusive bound check matching Interpreter::visit_for.
-int64_t rt_for_cond(Value *i, Value *end, Value *step);
+int64_t rt_for_cond(Value* i, Value* end, Value* step);
 // Errors out (like the interpreter) when step == 0.
-void rt_for_step_check(Value *step);
+void rt_for_step_check(Value* step);
 
-Value *rt_index(Value *obj, Value *idx);
-Value *rt_index_assign(Value *obj, Value *idx, Value *v);
-Value *rt_member_access(Value *obj, const char *name);
-Value *rt_member_assign(Value *obj, const char *name, Value *v);
+Value* rt_index(Value* obj, Value* idx);
+Value* rt_index_assign(Value* obj, Value* idx, Value* v);
+Value* rt_member_access(Value* obj, const char* name);
+Value* rt_member_assign(Value* obj, const char* name, Value* v);
 
-Value *rt_define_algo(const char *name, Value *(*fn)(),
-                      const char *const *arg_names, int64_t nargs);
-Value *rt_call(Value *callee, Value **argv, int64_t argc);
+// `memoizable` enables the same by-argument result caching the interpreter
+// applies to recursive pure-numeric algorithms.
+Value* rt_define_algo(const char* name, Value* (*fn)(), const char* const* arg_names, int64_t nargs,
+                      int64_t memoizable);
+Value* rt_call(Value* callee, Value** argv, int64_t argc);
 
 int64_t rt_frame_mark();
 void rt_frame_push();
 void rt_frame_release(int64_t mark);
 // Replaces the contents of frame `frame_index` with just `v`: keeps the
 // current loop variable alive for one iteration without per-iteration growth.
-void rt_loop_keep(int64_t frame_index, Value *v);
+void rt_loop_keep(int64_t frame_index, Value* v);
 }
 
 #endif

From 837982d33314db3e77da39278ab743ccc69d1ccf Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:39:56 +0800
Subject: [PATCH 08/12] style: clang-format files touched by the compiler work

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/interpreter.cpp |  418 ++++----
 src/node.h          |  332 +++---
 src/pseudo.cpp      | 2331 ++++++++++++++++++++-----------------------
 src/value.h         |  178 ++--
 4 files changed, 1570 insertions(+), 1689 deletions(-)

diff --git a/src/interpreter.cpp b/src/interpreter.cpp
index c2589e4..0d17bfb 100644
--- a/src/interpreter.cpp
+++ b/src/interpreter.cpp
@@ -3,14 +3,16 @@
 /// --------------------
 
 #include "interpreter.h"
-#include "node.h"
-#include "value.h"
+
+#include <functional>
 #include <iostream>
 #include <memory>
-#include <functional>
 #include <stdexcept>
 #include <unordered_map>
 
+#include "node.h"
+#include "value.h"
+
 namespace {
 constexpr int JIT_HOT_THRESHOLD = 8;
 
@@ -42,77 +44,78 @@ bool has_assignment_node(const std::shared_ptr<Node>& node) {
     }
     return false;
 }
-} // namespace
+}  // namespace
 
 std::shared_ptr<Value> Interpreter::visit(std::shared_ptr<Node> node) {
     if (std::optional<std::shared_ptr<Value>> jit_result = try_visit_jit(node)) {
         return *jit_result;
     }
 
-    if(node->get_type() == NODE_VALUE) {
+    if (node->get_type() == NODE_VALUE) {
         return visit_number(node);
     }
-    if(node->get_type() == NODE_VARACCESS) {
+    if (node->get_type() == NODE_VARACCESS) {
         return visit_var_access(node);
     }
-    if(node->get_type() == NODE_VARASSIGN) {
+    if (node->get_type() == NODE_VARASSIGN) {
         return visit_var_assign(node);
     }
-    if(node->get_type() == NODE_BINOP) {
+    if (node->get_type() == NODE_BINOP) {
         return visit_bin_op(node);
     }
-    if(node->get_type() == NODE_UNARYOP) {
+    if (node->get_type() == NODE_UNARYOP) {
         return visit_unary_op(node);
     }
-    if(node->get_type() == NODE_IF) {
+    if (node->get_type() == NODE_IF) {
         return visit_if(node);
     }
-    if(node->get_type() == NODE_FOR) {
+    if (node->get_type() == NODE_FOR) {
         return visit_for(node);
     }
-    if(node->get_type() == NODE_WHILE) {
+    if (node->get_type() == NODE_WHILE) {
         return visit_while(node);
     }
-    if(node->get_type() == NODE_REPEAT) {
+    if (node->get_type() == NODE_REPEAT) {
         return visit_repeat(node);
     }
-    if(node->get_type() == NODE_ALGODEF) {
+    if (node->get_type() == NODE_ALGODEF) {
         return visit_algo_def(node);
     }
-    if(node->get_type() == NODE_STRUCTDEF) {
+    if (node->get_type() == NODE_STRUCTDEF) {
         return visit_struct_def(node);
     }
-    if(node->get_type() == NODE_ALGOCALL) {
+    if (node->get_type() == NODE_ALGOCALL) {
         return visit_algo_call(node);
     }
-    if(node->get_type() == NODE_ARRAY) {
+    if (node->get_type() == NODE_ARRAY) {
         return visit_array(node);
     }
-    if(node->get_type() == NODE_ARRACCESS) {
+    if (node->get_type() == NODE_ARRACCESS) {
         return visit_array_access(node);
     }
-    if(node->get_type() == NODE_ARRASSIGN) {
+    if (node->get_type() == NODE_ARRASSIGN) {
         return visit_array_assign(node);
     }
-    if(node->get_type() == NODE_MEMACCESS) {
+    if (node->get_type() == NODE_MEMACCESS) {
         return visit_member_access(node);
     }
-    if(node->get_type() == NODE_RETURN) {
+    if (node->get_type() == NODE_RETURN) {
         return visit_return(node);
     }
-    if(node->get_type() == NODE_BREAK) {
+    if (node->get_type() == NODE_BREAK) {
         return std::make_shared<ControlValue>(VALUE_BREAK);
     }
-    if(node->get_type() == NODE_CONTINUE) {
+    if (node->get_type() == NODE_CONTINUE) {
         return std::make_shared<ControlValue>(VALUE_CONTINUE);
     }
-    if(node->get_type() == NODE_PRECOMPUTED) {
+    if (node->get_type() == NODE_PRECOMPUTED) {
         return dynamic_cast<PrecomputedNode*>(node.get())->get_value();
     }
     return std::make_shared<ErrorValue>(VALUE_ERROR, "Fail to get result\n");
 }
 
-std::optional<std::shared_ptr<Value>> Interpreter::try_visit_jit(const std::shared_ptr<Node>& node) {
+std::optional<std::shared_ptr<Value>> Interpreter::try_visit_jit(
+    const std::shared_ptr<Node>& node) {
     static std::unordered_map<std::size_t, JitCacheEntry> jit_cache;
 
     if (!is_jit_root(node)) {
@@ -143,12 +146,15 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_jit(const std::shar
 }
 
 std::shared_ptr<Value> Interpreter::visit_number(std::shared_ptr<Node> node) {
-    if(node->get_tok()->get_type() == TOKEN_INT) 
-        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, std::stoll(node->get_tok()->get_value()));
-    else if(node->get_tok()->get_type() == TOKEN_FLOAT)
-        return std::make_shared<TypedValue<double>>(VALUE_FLOAT, std::stod(node->get_tok()->get_value()));
-    else if(node->get_tok()->get_type() == TOKEN_STRING)
-        return std::make_shared<TypedValue<std::string>>(VALUE_STRING, node->get_tok()->get_value());
+    if (node->get_tok()->get_type() == TOKEN_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
+                                                     std::stoll(node->get_tok()->get_value()));
+    else if (node->get_tok()->get_type() == TOKEN_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT,
+                                                    std::stod(node->get_tok()->get_value()));
+    else if (node->get_tok()->get_type() == TOKEN_STRING)
+        return std::make_shared<TypedValue<std::string>>(VALUE_STRING,
+                                                         node->get_tok()->get_value());
     else
         return std::make_shared<ErrorValue>(VALUE_ERROR, "Not a value type\n");
 }
@@ -170,15 +176,15 @@ std::shared_ptr<Value> Interpreter::visit_var_assign(std::shared_ptr<Node> node)
                 if (suffix->get_type() == VALUE_ERROR) {
                     return suffix;
                 }
-                if (suffix->get_type() == VALUE_STRING && current->append_string(suffix->as_string())) {
+                if (suffix->get_type() == VALUE_STRING &&
+                    current->append_string(suffix->as_string())) {
                     return current;
                 }
             }
         }
     }
     std::shared_ptr<Value> value = visit(child[0]);
-    if(value->get_type() == VALUE_ERROR)
-        return value;
+    if (value->get_type() == VALUE_ERROR) return value;
     symbol_table.set(var_name, value);
     return symbol_table.get(var_name);
 }
@@ -187,42 +193,35 @@ std::shared_ptr<Value> Interpreter::visit_bin_op(std::shared_ptr<Node> node) {
     NodeList child = node->get_child();
     std::shared_ptr<Value> a, b;
     a = visit(child[0]);
-    if(a->get_type() == VALUE_ERROR)
-        return a;
-    if(node->get_tok()->get_type() == TOKEN_KEYWORD && node->get_tok()->get_value() == "and") {
-        if(a->as_int() == 0)
-            return std::make_shared<TypedValue<int64_t>>(VALUE_INT, 0);
+    if (a->get_type() == VALUE_ERROR) return a;
+    if (node->get_tok()->get_type() == TOKEN_KEYWORD && node->get_tok()->get_value() == "and") {
+        if (a->as_int() == 0) return std::make_shared<TypedValue<int64_t>>(VALUE_INT, 0);
         b = visit(child[1]);
-        if(b->get_type() == VALUE_ERROR)
-            return b;
+        if (b->get_type() == VALUE_ERROR) return b;
         return std::make_shared<TypedValue<int64_t>>(VALUE_INT, b->as_int() != 0);
     }
-    if(node->get_tok()->get_type() == TOKEN_KEYWORD && node->get_tok()->get_value() == "or") {
-        if(a->as_int() != 0)
-            return std::make_shared<TypedValue<int64_t>>(VALUE_INT, 1);
+    if (node->get_tok()->get_type() == TOKEN_KEYWORD && node->get_tok()->get_value() == "or") {
+        if (a->as_int() != 0) return std::make_shared<TypedValue<int64_t>>(VALUE_INT, 1);
         b = visit(child[1]);
-        if(b->get_type() == VALUE_ERROR)
-            return b;
+        if (b->get_type() == VALUE_ERROR) return b;
         return std::make_shared<TypedValue<int64_t>>(VALUE_INT, b->as_int() != 0);
     }
     b = visit(child[1]);
-    if(b->get_type() == VALUE_ERROR)
-        return b;
+    if (b->get_type() == VALUE_ERROR) return b;
     return bin_op(a, b, node->get_tok());
 }
 
 std::shared_ptr<Value> Interpreter::visit_unary_op(std::shared_ptr<Node> node) {
     NodeList child = node->get_child();
     std::shared_ptr<Value> a = visit(child[0]);
-    if(a->get_type() == VALUE_ERROR)
-        return a;
+    if (a->get_type() == VALUE_ERROR) return a;
     return unary_op(a, node->get_tok());
 }
 
 std::shared_ptr<Value> Interpreter::visit_array(std::shared_ptr<Node> node) {
     NodeList child = node->get_child();
     ValueList array_value;
-    for(int i{0}; i < child.size(); ++i) {
+    for (int i{0}; i < child.size(); ++i) {
         array_value.push_back(visit(child[i]));
     }
     return std::make_shared<ArrayValue>(array_value);
@@ -231,27 +230,27 @@ std::shared_ptr<Value> Interpreter::visit_array(std::shared_ptr<Node> node) {
 std::shared_ptr<Value>& Interpreter::visit_array_access(std::shared_ptr<Node> node) {
     NodeList child{node->get_child()};
     std::shared_ptr<Value> arr{visit(child[0])}, index{visit(child[1])};
-    if(arr->get_type() == VALUE_STRING) {
+    if (arr->get_type() == VALUE_STRING) {
         std::string str = arr->as_string();
         int p = index->as_int();
         if (1 <= p && p <= static_cast<int>(str.size())) {
-            error = std::make_shared<TypedValue<std::string>>(
-                VALUE_STRING, std::string(1, str[p - 1]));
+            error =
+                std::make_shared<TypedValue<std::string>>(VALUE_STRING, std::string(1, str[p - 1]));
         } else {
             error = std::make_shared<ErrorValue>(
                 VALUE_ERROR, "Index out of range, size: " + std::to_string(str.size()) +
-                             ", position: " + std::to_string(p));
+                                 ", position: " + std::to_string(p));
         }
         return error;
     }
-    if(arr->get_type() == VALUE_HASH_TABLE) {
+    if (arr->get_type() == VALUE_HASH_TABLE) {
         algo_call_temp = arr;
         error = dynamic_cast<HashTableValue*>(arr.get())->get(index);
         return error;
     }
-    if(arr->get_type() != VALUE_ARRAY) {
-        error = std::make_shared<ErrorValue>(VALUE_ERROR, "Access can only apply on array, find " + 
-            arr->get_type() + "\n");
+    if (arr->get_type() != VALUE_ARRAY) {
+        error = std::make_shared<ErrorValue>(
+            VALUE_ERROR, "Access can only apply on array, find " + arr->get_type() + "\n");
         return error;
     }
     algo_call_temp = arr;
@@ -260,11 +259,11 @@ std::shared_ptr<Value>& Interpreter::visit_array_access(std::shared_ptr<Node> no
 
 std::shared_ptr<Value> Interpreter::visit_array_assign(std::shared_ptr<Node> node) {
     NodeList child{node->get_child()};
-    if(child[0]->get_type() == NODE_MEMACCESS) {
+    if (child[0]->get_type() == NODE_MEMACCESS) {
         // Handle member assignment: obj.member <- val
-        // visit_member_access currently returns a value (possibly a BoundMethodValue or just a value).
-        // But for assignment we need to set the member.
-        // We need to unpack NODE_MEMACCESS to get obj and member name.
+        // visit_member_access currently returns a value (possibly a BoundMethodValue or just a
+        // value). But for assignment we need to set the member. We need to unpack NODE_MEMACCESS to
+        // get obj and member name.
         std::shared_ptr<Node> obj_node = child[0]->get_child()[0];
         std::shared_ptr<Node> member_node = child[0]->get_child()[1];
 
@@ -276,10 +275,12 @@ std::shared_ptr<Value> Interpreter::visit_array_assign(std::shared_ptr<Node> nod
             inst->set_member(member_node->get_name(), val);
             return val;
         } else {
-             return std::make_shared<ErrorValue>(VALUE_ERROR, "Assignment to member only supported for Struct Instances\n");
+            return std::make_shared<ErrorValue>(
+                VALUE_ERROR, "Assignment to member only supported for Struct Instances\n");
         }
-    } else if(child[0]->get_type() != NODE_ARRACCESS) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR, "Access can only apply on array or object member\n");
+    } else if (child[0]->get_type() != NODE_ARRACCESS) {
+        return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                            "Access can only apply on array or object member\n");
     }
     NodeList access_child{child[0]->get_child()};
     std::shared_ptr<Value> obj{visit(access_child[0])};
@@ -290,17 +291,17 @@ std::shared_ptr<Value> Interpreter::visit_array_assign(std::shared_ptr<Node> nod
         if (value->get_type() == VALUE_ERROR) return value;
         return dynamic_cast<HashTableValue*>(obj.get())->set(key, value);
     }
-    std::shared_ptr<Value> &arr{visit_array_access(child[0])}, value{visit(child[1])};
+    std::shared_ptr<Value>&arr{visit_array_access(child[0])}, value{visit(child[1])};
     return arr = value;
 }
 
 std::shared_ptr<Value> Interpreter::visit_member_access(std::shared_ptr<Node> node) {
     NodeList child{node->get_child()};
     std::shared_ptr<Value> obj{visit(child[0])};
-    std::shared_ptr<Node> &member{child[1]};
+    std::shared_ptr<Node>& member{child[1]};
 
-    if(obj->get_type() == VALUE_ARRAY || obj->get_type() == VALUE_STRING ||
-       obj->get_type() == VALUE_HASH_TABLE) {
+    if (obj->get_type() == VALUE_ARRAY || obj->get_type() == VALUE_STRING ||
+        obj->get_type() == VALUE_HASH_TABLE) {
         std::string member_name = member->get_name();
         return std::make_shared<BoundMethodValue>(obj, member_name);
     } else if (obj->get_type() == VALUE_INSTANCE) {
@@ -308,33 +309,33 @@ std::shared_ptr<Value> Interpreter::visit_member_access(std::shared_ptr<Node> no
         InstanceValue* inst = dynamic_cast<InstanceValue*>(obj.get());
         return inst->get_member(member_name, obj);
     }
-    error = std::make_shared<ErrorValue>(VALUE_ERROR, obj->get_num() + " has no member " + member->get_name() + "\n");
+    error = std::make_shared<ErrorValue>(
+        VALUE_ERROR, obj->get_num() + " has no member " + member->get_name() + "\n");
     return error;
-} 
+}
 
 std::shared_ptr<Value> Interpreter::visit_if(std::shared_ptr<Node> node) {
     IfNode* if_node = dynamic_cast<IfNode*>(node.get());
     std::shared_ptr<Value> cond = visit(if_node->get_condition());
-    if(cond->get_type() == VALUE_ERROR)
-        return cond;
-    if(std::stoll(cond->get_num()) == 1) {
+    if (cond->get_type() == VALUE_ERROR) return cond;
+    if (std::stoll(cond->get_num()) == 1) {
         std::shared_ptr<Value> ret;
-        for(auto expr : if_node->get_expr()) {
+        for (auto expr : if_node->get_expr()) {
             ret = visit(expr);
-                if(ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN ||
-                   ret->get_type() == VALUE_BREAK || ret->get_type() == VALUE_CONTINUE) {
-                    return ret;
-                }
+            if (ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN ||
+                ret->get_type() == VALUE_BREAK || ret->get_type() == VALUE_CONTINUE) {
+                return ret;
+            }
         }
         return ret;
-    } else if(!if_node->get_else().empty()) {
+    } else if (!if_node->get_else().empty()) {
         std::shared_ptr<Value> ret;
-        for(auto expr : if_node->get_else()) {
+        for (auto expr : if_node->get_else()) {
             ret = visit(expr);
-                if(ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN ||
-                   ret->get_type() == VALUE_BREAK || ret->get_type() == VALUE_CONTINUE) {
-                    return ret;
-                }
+            if (ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN ||
+                ret->get_type() == VALUE_BREAK || ret->get_type() == VALUE_CONTINUE) {
+                return ret;
+            }
         }
         return ret;
     }
@@ -346,22 +347,22 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
     std::shared_ptr<Value> i = visit(child[0]);
     if (i->get_type() == VALUE_ERROR) return i;
     std::shared_ptr<Value> step;
-    if(child[2] != nullptr) {
+    if (child[2] != nullptr) {
         step = visit(child[2]);
         if (step->get_type() == VALUE_ERROR) return step;
     } else {
         step = std::make_shared<TypedValue<int64_t>>(VALUE_INT, 1);
     }
     std::shared_ptr<Value> end_value = visit(child[1]);
-    if(end_value->get_type() == VALUE_ERROR) return end_value;
+    if (end_value->get_type() == VALUE_ERROR) return end_value;
     std::function<bool(std::shared_ptr<Value>, std::shared_ptr<Value>)> condition;
-    if(step->as_double() > 0) {
+    if (step->as_double() > 0) {
         condition = [](std::shared_ptr<Value> i, std::shared_ptr<Value> end) -> bool {
             if (i->get_type() == VALUE_FLOAT || end->get_type() == VALUE_FLOAT)
                 return i->as_double() <= end->as_double();
             return i->as_int() <= end->as_int();
         };
-    } else if(step->as_double() < 0) {
+    } else if (step->as_double() < 0) {
         condition = [](std::shared_ptr<Value> i, std::shared_ptr<Value> end) -> bool {
             if (i->get_type() == VALUE_FLOAT || end->get_type() == VALUE_FLOAT)
                 return i->as_double() >= end->as_double();
@@ -387,7 +388,8 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
             fast_assign_name = child[3]->get_name();
             fast_assign_program = ExpressionJit::compile(assign_child[0]);
             if (!fast_assign_program && assign_child[0]->get_type() == NODE_ALGOCALL) {
-                AlgorithmCallNode* call_node = dynamic_cast<AlgorithmCallNode*>(assign_child[0].get());
+                AlgorithmCallNode* call_node =
+                    dynamic_cast<AlgorithmCallNode*>(assign_child[0].get());
                 if (call_node->get_call()->get_type() == NODE_VARACCESS) {
                     std::shared_ptr<Value> callee = symbol_table.get(call_node->get_name());
                     AlgoValue* algo = dynamic_cast<AlgoValue*>(callee.get());
@@ -402,7 +404,8 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
                             if (fast_call_body_program) {
                                 bool args_compiled = true;
                                 for (const auto& arg : call_node->get_args()) {
-                                    std::optional<JitProgram> arg_program = ExpressionJit::compile(arg);
+                                    std::optional<JitProgram> arg_program =
+                                        ExpressionJit::compile(arg);
                                     if (!arg_program) {
                                         args_compiled = false;
                                         break;
@@ -439,18 +442,16 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
     }
 
     ValueList ret;
-    while(condition(i, end_value)) {
+    while (condition(i, end_value)) {
         if (fast_assign_program) {
             std::optional<std::shared_ptr<Value>> val = fast_assign_program->execute(symbol_table);
             if (!val) {
                 fast_assign_program.reset();
                 std::shared_ptr<Value> fallback = visit(child[3]);
-                if(fallback->get_type() == VALUE_ERROR || fallback->get_type() == VALUE_RETURN)
+                if (fallback->get_type() == VALUE_ERROR || fallback->get_type() == VALUE_RETURN)
                     return fallback;
-                if(fallback->get_type() == VALUE_BREAK)
-                    goto end_for_loop;
-                if(fallback->get_type() == VALUE_CONTINUE)
-                    goto next_for_iteration;
+                if (fallback->get_type() == VALUE_BREAK) goto end_for_loop;
+                if (fallback->get_type() == VALUE_CONTINUE) goto next_for_iteration;
             } else {
                 if ((*val)->get_type() == VALUE_ERROR || (*val)->get_type() == VALUE_RETURN)
                     return *val;
@@ -464,8 +465,7 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
                 std::optional<std::shared_ptr<Value>> arg =
                     fast_call_arg_programs[arg_index].execute(symbol_table);
                 if (!arg || (*arg)->get_type() == VALUE_ERROR) {
-                    if (arg && (*arg)->get_type() == VALUE_ERROR)
-                        return *arg;
+                    if (arg && (*arg)->get_type() == VALUE_ERROR) return *arg;
                     failed = true;
                     break;
                 }
@@ -480,7 +480,8 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
                     fast_call_body_program->execute(symbol_table);
                 if (!val) {
                     failed = true;
-                } else if ((*val)->get_type() == VALUE_ERROR || (*val)->get_type() == VALUE_RETURN) {
+                } else if ((*val)->get_type() == VALUE_ERROR ||
+                           (*val)->get_type() == VALUE_RETURN) {
                     return *val;
                 } else if ((*val)->get_type() == VALUE_BREAK) {
                     goto end_for_loop;
@@ -491,8 +492,8 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
                 }
             }
 
-            for (int arg_index = static_cast<int>(had_saved_values.size()) - 1;
-                 arg_index >= 0; --arg_index) {
+            for (int arg_index = static_cast<int>(had_saved_values.size()) - 1; arg_index >= 0;
+                 --arg_index) {
                 if (had_saved_values[arg_index]) {
                     symbol_table.set(fast_call_arg_names[arg_index], saved_values[arg_index]);
                 } else {
@@ -503,59 +504,48 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
             if (failed) {
                 fast_call_body_program.reset();
                 std::shared_ptr<Value> fallback = visit(child[3]);
-                if(fallback->get_type() == VALUE_ERROR || fallback->get_type() == VALUE_RETURN)
+                if (fallback->get_type() == VALUE_ERROR || fallback->get_type() == VALUE_RETURN)
                     return fallback;
-                if(fallback->get_type() == VALUE_BREAK)
-                    goto end_for_loop;
-                if(fallback->get_type() == VALUE_CONTINUE)
-                    goto next_for_iteration;
+                if (fallback->get_type() == VALUE_BREAK) goto end_for_loop;
+                if (fallback->get_type() == VALUE_CONTINUE) goto next_for_iteration;
             }
         } else if (fast_array && fast_array_index_program && fast_array_value_program) {
-            std::optional<std::shared_ptr<Value>> index = fast_array_index_program->execute(symbol_table);
-            std::optional<std::shared_ptr<Value>> val = fast_array_value_program->execute(symbol_table);
+            std::optional<std::shared_ptr<Value>> index =
+                fast_array_index_program->execute(symbol_table);
+            std::optional<std::shared_ptr<Value>> val =
+                fast_array_value_program->execute(symbol_table);
             if (!index || !val) {
                 fast_array = nullptr;
                 std::shared_ptr<Value> fallback = visit(child[3]);
-                if(fallback->get_type() == VALUE_ERROR || fallback->get_type() == VALUE_RETURN)
+                if (fallback->get_type() == VALUE_ERROR || fallback->get_type() == VALUE_RETURN)
                     return fallback;
-                if(fallback->get_type() == VALUE_BREAK)
-                    goto end_for_loop;
-                if(fallback->get_type() == VALUE_CONTINUE)
-                    goto next_for_iteration;
+                if (fallback->get_type() == VALUE_BREAK) goto end_for_loop;
+                if (fallback->get_type() == VALUE_CONTINUE) goto next_for_iteration;
             } else {
-                if ((*index)->get_type() == VALUE_ERROR)
-                    return *index;
+                if ((*index)->get_type() == VALUE_ERROR) return *index;
                 if ((*val)->get_type() == VALUE_ERROR || (*val)->get_type() == VALUE_RETURN)
                     return *val;
-                if ((*val)->get_type() == VALUE_BREAK)
-                    goto end_for_loop;
-                if ((*val)->get_type() == VALUE_CONTINUE)
-                    goto next_for_iteration;
+                if ((*val)->get_type() == VALUE_BREAK) goto end_for_loop;
+                if ((*val)->get_type() == VALUE_CONTINUE) goto next_for_iteration;
                 fast_array->operator[]((*index)->as_int()) = *val;
             }
-        } else if(child.size() == 4) {
+        } else if (child.size() == 4) {
             std::shared_ptr<Value> val = visit(child[3]);
-            if(val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) 
-                return val;
-            if(val->get_type() == VALUE_BREAK)
-                goto end_for_loop;
-            if(val->get_type() == VALUE_CONTINUE)
-                goto next_for_iteration;
+            if (val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) return val;
+            if (val->get_type() == VALUE_BREAK) goto end_for_loop;
+            if (val->get_type() == VALUE_CONTINUE) goto next_for_iteration;
             if (collect_loop_results) {
                 ret.push_back(val);
             }
         } else {
-            for(int index{3}; index < child.size(); ++index) {
+            for (int index{3}; index < child.size(); ++index) {
                 std::shared_ptr<Value> val{visit(child[index])};
-                if(val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) 
-                    return val;
-                if(val->get_type() == VALUE_BREAK)
-                    goto end_for_loop;
-                if(val->get_type() == VALUE_CONTINUE)
-                    goto next_for_iteration;
+                if (val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) return val;
+                if (val->get_type() == VALUE_BREAK) goto end_for_loop;
+                if (val->get_type() == VALUE_CONTINUE) goto next_for_iteration;
             }
         }
-next_for_iteration:
+    next_for_iteration:
         symbol_table.set(child[0]->get_name(), i + step);
         i = symbol_table.get(child[0]->get_name());
     }
@@ -564,46 +554,39 @@ std::shared_ptr<Value> Interpreter::visit_for(std::shared_ptr<Node> node) {
         static std::shared_ptr<Value> none = std::make_shared<Value>();
         return none;
     }
-    if(child.size() != 4)
-        ret.push_back(std::make_shared<Value>());
+    if (child.size() != 4) ret.push_back(std::make_shared<Value>());
     return std::make_shared<ArrayValue>(ret);
 }
 
 std::shared_ptr<Value> Interpreter::visit_while(std::shared_ptr<Node> node) {
     NodeList child = node->get_child();
     ValueList ret;
-    while(visit(child[0])->as_int() == 1) {
-        if(child.size() == 2) {
+    while (visit(child[0])->as_int() == 1) {
+        if (child.size() == 2) {
             std::shared_ptr<Value> val = visit(child[1]);
-            if(val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) 
-                return val;
-            if(val->get_type() == VALUE_BREAK)
-                break;
-            if(val->get_type() == VALUE_CONTINUE)
-                continue;
+            if (val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) return val;
+            if (val->get_type() == VALUE_BREAK) break;
+            if (val->get_type() == VALUE_CONTINUE) continue;
             if (collect_loop_results) {
                 ret.push_back(val);
             }
         } else {
             bool should_continue = false;
             bool should_break = false;
-            for(int index{1}; index < child.size(); ++index) {
+            for (int index{1}; index < child.size(); ++index) {
                 std::shared_ptr<Value> ret{visit(child[index])};
-                if(ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN)
-                    return ret;
-                if(ret->get_type() == VALUE_BREAK) {
+                if (ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN) return ret;
+                if (ret->get_type() == VALUE_BREAK) {
                     should_break = true;
                     break;
                 }
-                if(ret->get_type() == VALUE_CONTINUE) {
+                if (ret->get_type() == VALUE_CONTINUE) {
                     should_continue = true;
                     break;
                 }
             }
-            if(should_break)
-                break;
-            if(should_continue)
-                continue;
+            if (should_break) break;
+            if (should_continue) continue;
         }
     }
     if (!collect_loop_results) {
@@ -617,39 +600,33 @@ std::shared_ptr<Value> Interpreter::visit_repeat(std::shared_ptr<Node> node) {
     NodeList child = node->get_child();
     ValueList ret;
     do {
-        if(child.size() == 2) {
+        if (child.size() == 2) {
             std::shared_ptr<Value> val = visit(child[1]);
-            if(val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) 
-                return val;
-            if(val->get_type() == VALUE_BREAK)
-                break;
-            if(val->get_type() == VALUE_CONTINUE)
-                continue;
+            if (val->get_type() == VALUE_ERROR || val->get_type() == VALUE_RETURN) return val;
+            if (val->get_type() == VALUE_BREAK) break;
+            if (val->get_type() == VALUE_CONTINUE) continue;
             if (collect_loop_results) {
                 ret.push_back(val);
             }
         } else {
             bool should_continue = false;
             bool should_break = false;
-            for(int index{1}; index < child.size(); ++index) {
+            for (int index{1}; index < child.size(); ++index) {
                 std::shared_ptr<Value> ret{visit(child[index])};
-                if(ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN)
-                    return ret;
-                if(ret->get_type() == VALUE_BREAK) {
+                if (ret->get_type() == VALUE_ERROR || ret->get_type() == VALUE_RETURN) return ret;
+                if (ret->get_type() == VALUE_BREAK) {
                     should_break = true;
                     break;
                 }
-                if(ret->get_type() == VALUE_CONTINUE) {
+                if (ret->get_type() == VALUE_CONTINUE) {
                     should_continue = true;
                     break;
                 }
             }
-            if(should_break)
-                break;
-            if(should_continue)
-                continue;
+            if (should_break) break;
+            if (should_continue) continue;
         }
-    } while(visit(child[0])->as_int() == 0);
+    } while (visit(child[0])->as_int() == 0);
     if (!collect_loop_results) {
         static std::shared_ptr<Value> none = std::make_shared<Value>();
         return none;
@@ -660,12 +637,12 @@ std::shared_ptr<Value> Interpreter::visit_repeat(std::shared_ptr<Node> node) {
 std::shared_ptr<Value> Interpreter::visit_algo_def(std::shared_ptr<Node> node) {
     std::string algo_name = node->get_name();
     std::shared_ptr<Value> value = std::make_shared<AlgoValue>(algo_name, node);
-    
+
     size_t pos = algo_name.find("::");
     if (pos != std::string::npos) {
         std::string struct_name = algo_name.substr(0, pos);
         std::string method_name = algo_name.substr(pos + 2);
-        
+
         std::shared_ptr<Value> struct_val = symbol_table.get(struct_name);
         if (struct_val->get_type() == VALUE_STRUCT) {
             StructValue* s = dynamic_cast<StructValue*>(struct_val.get());
@@ -687,18 +664,19 @@ std::shared_ptr<Value> Interpreter::visit_algo_call(std::shared_ptr<Node> node)
         return *array_result;
     }
 
-    AlgorithmCallNode *algo_call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
+    AlgorithmCallNode* algo_call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
     std::shared_ptr<Node> algo_node = algo_call_node->get_call();
     std::shared_ptr<Value> algo;
-    if(algo_node->get_type() == NODE_VARACCESS)
+    if (algo_node->get_type() == NODE_VARACCESS)
         algo = symbol_table.get(algo_call_node->get_name());
     else
         algo = visit(algo_node);
     return algo->execute(algo_call_node->get_args(), &symbol_table);
 }
 
-std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(const std::shared_ptr<Node>& node) {
-    AlgorithmCallNode *algo_call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
+std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(
+    const std::shared_ptr<Node>& node) {
+    AlgorithmCallNode* algo_call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
     if (!algo_call_node) {
         return std::nullopt;
     }
@@ -711,11 +689,9 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
     NodeList member_child = call_node->get_child();
     const std::string method_name = member_child[1]->get_name();
     const bool supported_method =
-        method_name == "push" || method_name == "push_back" ||
-        method_name == "pop" || method_name == "pop_back" ||
-        method_name == "resize" || method_name == "size" ||
-        method_name == "back" || method_name == "insert" ||
-        method_name == "remove";
+        method_name == "push" || method_name == "push_back" || method_name == "pop" ||
+        method_name == "pop_back" || method_name == "resize" || method_name == "size" ||
+        method_name == "back" || method_name == "insert" || method_name == "remove";
     if (!supported_method || member_child[0]->get_type() != NODE_VARACCESS) {
         return std::nullopt;
     }
@@ -724,7 +700,7 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
     if (obj->get_type() != VALUE_ARRAY) {
         return std::nullopt;
     }
-    ArrayValue *arr_obj = dynamic_cast<ArrayValue *>(obj.get());
+    ArrayValue* arr_obj = dynamic_cast<ArrayValue*>(obj.get());
     const NodeList& args = algo_call_node->get_args();
 
     auto visit_arg = [this](const std::shared_ptr<Node>& arg) -> std::shared_ptr<Value> {
@@ -738,8 +714,8 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
 
     if (method_name == "push" || method_name == "push_back") {
         if (args.size() != 1) {
-            return std::make_shared<ErrorValue>(
-                VALUE_ERROR, "Expect one argument for " + method_name + "\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                "Expect one argument for " + method_name + "\n");
         }
         std::shared_ptr<Value> arg = visit_arg(args[0]);
         if (arg->get_type() == VALUE_ERROR) {
@@ -751,8 +727,8 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
 
     if (method_name == "pop" || method_name == "pop_back") {
         if (!args.empty()) {
-            return std::make_shared<ErrorValue>(
-                VALUE_ERROR, "Expect zero argument for " + method_name + "\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                "Expect zero argument for " + method_name + "\n");
         }
         if (arr_obj->empty()) {
             std::cout << "Cannot " << method_name << " from an empty array\n";
@@ -763,8 +739,7 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
 
     if (method_name == "resize") {
         if (args.size() != 1) {
-            return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                                "Expect one argument for resize\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect one argument for resize\n");
         }
         std::shared_ptr<Value> new_size_val = visit_arg(args[0]);
         if (new_size_val->get_type() == VALUE_ERROR) {
@@ -791,8 +766,7 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
 
     if (method_name == "insert") {
         if (args.size() != 2) {
-            return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                                "Expect two arguments for insert\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect two arguments for insert\n");
         }
         std::shared_ptr<Value> index = visit_arg(args[0]);
         if (index->get_type() == VALUE_ERROR) {
@@ -807,8 +781,7 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
 
     if (method_name == "remove") {
         if (args.size() != 1) {
-            return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                                "Expect one argument for remove\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect one argument for remove\n");
         }
         std::shared_ptr<Value> index = visit_arg(args[0]);
         if (index->get_type() == VALUE_ERROR) {
@@ -819,20 +792,18 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
 
     if (method_name == "size") {
         if (!args.empty()) {
-            return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                                "Expect zero argument for size\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect zero argument for size\n");
         }
         return arr_obj->size();
     }
 
     if (method_name == "back") {
         if (!args.empty()) {
-            return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                                "Expect zero arguments for back\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect zero arguments for back\n");
         }
         if (arr_obj->empty()) {
-            return std::make_shared<ErrorValue>(
-                VALUE_ERROR, "Cannot call back on an empty array\n");
+            return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                "Cannot call back on an empty array\n");
         }
         return arr_obj->back();
     }
@@ -840,50 +811,50 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(c
     return std::nullopt;
 }
 
-std::shared_ptr<Value> Interpreter::bin_op(
-    std::shared_ptr<Value> a, std::shared_ptr<Value> b, std::shared_ptr<Token> op
-) {
-    if(op->get_type() == TOKEN_ADD)
+std::shared_ptr<Value> Interpreter::bin_op(std::shared_ptr<Value> a, std::shared_ptr<Value> b,
+                                           std::shared_ptr<Token> op) {
+    if (op->get_type() == TOKEN_ADD)
         return a + b;
-    else if(op->get_type() == TOKEN_SUB)
+    else if (op->get_type() == TOKEN_SUB)
         return a - b;
-    else if(op->get_type() == TOKEN_MUL)
+    else if (op->get_type() == TOKEN_MUL)
         return a * b;
-    else if(op->get_type() == TOKEN_DIV)
+    else if (op->get_type() == TOKEN_DIV)
         return a / b;
-    else if(op->get_type() == TOKEN_MOD)
+    else if (op->get_type() == TOKEN_MOD)
         return a % b;
-    else if(op->get_type() == TOKEN_POW)
+    else if (op->get_type() == TOKEN_POW)
         return pow(a, b);
-    else if(op->get_type() == TOKEN_EQUAL)
+    else if (op->get_type() == TOKEN_EQUAL)
         return a == b;
-    else if(op->get_type() == TOKEN_NEQ)
+    else if (op->get_type() == TOKEN_NEQ)
         return a != b;
-    else if(op->get_type() == TOKEN_LESS)
+    else if (op->get_type() == TOKEN_LESS)
         return a < b;
-    else if(op->get_type() == TOKEN_GREATER)
+    else if (op->get_type() == TOKEN_GREATER)
         return a > b;
-    else if(op->get_type() == TOKEN_LEQ)
+    else if (op->get_type() == TOKEN_LEQ)
         return a <= b;
-    else if(op->get_type() == TOKEN_GEQ)
+    else if (op->get_type() == TOKEN_GEQ)
         return a >= b;
-    else if(op->get_type() == TOKEN_KEYWORD && op->get_value() == "and")
+    else if (op->get_type() == TOKEN_KEYWORD && op->get_value() == "and")
         return a && b;
-    else if(op->get_type() == TOKEN_KEYWORD && op->get_value() == "or")
+    else if (op->get_type() == TOKEN_KEYWORD && op->get_value() == "or")
         return a || b;
-    
+
     return std::make_shared<ErrorValue>(VALUE_ERROR, "Not a binary op\n");
 }
 
 std::shared_ptr<Value> Interpreter::unary_op(std::shared_ptr<Value> a, std::shared_ptr<Token> op) {
-    if(op->get_type() == TOKEN_ADD)
+    if (op->get_type() == TOKEN_ADD)
         return a;
-    else if(op->get_type() == TOKEN_SUB)
+    else if (op->get_type() == TOKEN_SUB)
         return -a;
-    else if(op->get_type() == TOKEN_KEYWORD && op->get_value() == "not")
+    else if (op->get_type() == TOKEN_KEYWORD && op->get_value() == "not")
         return !a;
     return std::make_shared<ErrorValue>(VALUE_ERROR, "Not an unary op\n");
-}std::shared_ptr<Value> Interpreter::visit_struct_def(std::shared_ptr<Node> node) {
+}
+std::shared_ptr<Value> Interpreter::visit_struct_def(std::shared_ptr<Node> node) {
     auto struct_node = dynamic_cast<StructDefNode*>(node.get());
     std::string name = struct_node->get_name();
     std::vector<std::string> members;
@@ -893,7 +864,8 @@ std::shared_ptr<Value> Interpreter::unary_op(std::shared_ptr<Value> a, std::shar
 
     std::map<std::string, std::shared_ptr<Value>> methods;
     for (const auto& method_node : struct_node->get_child()) {
-        std::string method_name = method_node->get_name(); // This is the simple name "constructor", "add", etc.
+        std::string method_name =
+            method_node->get_name();  // This is the simple name "constructor", "add", etc.
         // We need to visit it to create an AlgoValue
         // But visit_algo_def puts it in symbol table. We don't want that for struct methods,
         // we want them inside the struct.
diff --git a/src/node.h b/src/node.h
index 752b129..4f8f779 100644
--- a/src/node.h
+++ b/src/node.h
@@ -7,10 +7,11 @@
 
 #include <atomic>
 #include <cstddef>
+#include <memory>
 #include <stdexcept>
 #include <string>
 #include <vector>
-#include <memory>
+
 #include "token.h"
 
 const std::string NODE_VALUE{"VALUE"};
@@ -37,291 +38,310 @@ const std::string NODE_PRECOMPUTED("PRECOMPUTED");
 const std::string TAB{"    "};
 
 class Node {
-public:
+   public:
     Node() : node_id(next_node_id.fetch_add(1, std::memory_order_relaxed)) {}
     virtual std::string get_node() = 0;
     virtual ~Node() {};
-    virtual std::vector<std::shared_ptr<Node>> get_child() { return std::vector<std::shared_ptr<Node>>(0);}
-    virtual std::string get_type() {return "NONE";}
-    virtual std::shared_ptr<Token> get_tok() { return nullptr;}
-    virtual TokenList get_toks() { return TokenList(0);}
-    virtual std::string get_name() { return "";}
-    std::size_t get_id() const { return node_id;}
-private:
+    virtual std::vector<std::shared_ptr<Node>> get_child() {
+        return std::vector<std::shared_ptr<Node>>(0);
+    }
+    virtual std::string get_type() { return "NONE"; }
+    virtual std::shared_ptr<Token> get_tok() { return nullptr; }
+    virtual TokenList get_toks() { return TokenList(0); }
+    virtual std::string get_name() { return ""; }
+    std::size_t get_id() const { return node_id; }
+
+   private:
     inline static std::atomic_size_t next_node_id{1};
     std::size_t node_id;
 };
 
 using NodeList = std::vector<std::shared_ptr<Node>>;
 
-class ErrorNode: public Node {
-public:
-    ErrorNode(std::shared_ptr<Token> _tok)
-        : tok(_tok) {}
+class ErrorNode : public Node {
+   public:
+    ErrorNode(std::shared_ptr<Token> _tok) : tok(_tok) {}
     std::string get_node() override;
-    std::shared_ptr<Token> get_tok() override { return tok;}
-    std::string get_type() override {return NODE_ERROR;}
-protected:
+    std::shared_ptr<Token> get_tok() override { return tok; }
+    std::string get_type() override { return NODE_ERROR; }
+
+   protected:
     std::shared_ptr<Token> tok;
 };
 
-class ValueNode: public Node {
-public:
-    ValueNode(std::shared_ptr<Token> _tok)
-        : tok(_tok) {}
+class ValueNode : public Node {
+   public:
+    ValueNode(std::shared_ptr<Token> _tok) : tok(_tok) {}
     std::string get_node() override;
-    std::string get_type() override {return NODE_VALUE;}
-    std::shared_ptr<Token> get_tok() override { return tok;}
-protected:
+    std::string get_type() override { return NODE_VALUE; }
+    std::shared_ptr<Token> get_tok() override { return tok; }
+
+   protected:
     std::shared_ptr<Token> tok;
 };
 
-class BinOpNode: public Node {
-public:
+class BinOpNode : public Node {
+   public:
     BinOpNode(std::shared_ptr<Node> left, std::shared_ptr<Node> right, std::shared_ptr<Token> tok)
         : left_node(left), right_node(right), op_tok(tok) {}
     std::string get_node() override;
     NodeList get_child() override;
-    std::string get_type() override {return NODE_BINOP;}
-    std::shared_ptr<Token> get_tok() override { return op_tok;}
-protected:
+    std::string get_type() override { return NODE_BINOP; }
+    std::shared_ptr<Token> get_tok() override { return op_tok; }
+
+   protected:
     std::shared_ptr<Node> left_node, right_node;
     std::shared_ptr<Token> op_tok;
 };
 
-class UnaryOpNode: public Node {
-public:
+class UnaryOpNode : public Node {
+   public:
     UnaryOpNode(std::shared_ptr<Node> _node, std::shared_ptr<Token> tok)
         : node(_node), op_tok(tok) {}
     std::string get_node() override;
     NodeList get_child() override;
-    std::string get_type() override { return NODE_UNARYOP;}
-    std::shared_ptr<Token> get_tok() override { return op_tok;}
-protected:
+    std::string get_type() override { return NODE_UNARYOP; }
+    std::shared_ptr<Token> get_tok() override { return op_tok; }
+
+   protected:
     std::shared_ptr<Node> node;
     std::shared_ptr<Token> op_tok;
 };
 
-class VarAssignNode: public Node {
-public:
-    VarAssignNode(std::string _name, std::shared_ptr<Node> _node)
-        : name(_name), node(_node) {}
+class VarAssignNode : public Node {
+   public:
+    VarAssignNode(std::string _name, std::shared_ptr<Node> _node) : name(_name), node(_node) {}
     std::string get_node() override;
-    NodeList get_child() override { return NodeList{node};}
-    std::string get_type() override { return NODE_VARASSIGN;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return name;}
-protected:
+    NodeList get_child() override { return NodeList{node}; }
+    std::string get_type() override { return NODE_VARASSIGN; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return name; }
+
+   protected:
     std::string name;
     std::shared_ptr<Node> node;
 };
 
-class VarAccessNode: public Node {
-public:
-    VarAccessNode(std::shared_ptr<Token> _tok)
-        : tok(_tok) {}
+class VarAccessNode : public Node {
+   public:
+    VarAccessNode(std::shared_ptr<Token> _tok) : tok(_tok) {}
     std::string get_node() override;
-    NodeList get_child() override { return NodeList(0);}
-    std::string get_type() override{ return NODE_VARACCESS;}
-    std::shared_ptr<Token> get_tok() override { return tok;}
-    std::string get_name() override {return tok->get_value();}
-protected:
+    NodeList get_child() override { return NodeList(0); }
+    std::string get_type() override { return NODE_VARACCESS; }
+    std::shared_ptr<Token> get_tok() override { return tok; }
+    std::string get_name() override { return tok->get_value(); }
+
+   protected:
     std::shared_ptr<Token> tok;
 };
 
-class IfNode: public Node {
-public:
+class IfNode : public Node {
+   public:
     IfNode(std::shared_ptr<Node> condition, NodeList expr, NodeList _else_node)
         : condition_node(condition), expr_node(expr), else_node(_else_node) {}
     std::string get_node() override;
     NodeList get_child() override {
         throw std::runtime_error("should not call get_child on if node");
     }
-    const std::shared_ptr<Node>& get_condition() { return condition_node;}
-    const NodeList& get_expr() { return expr_node;}
-    const NodeList& get_else() { return else_node;}
-    std::string get_type() override{ return NODE_IF;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return "";}
-protected:
-    std::shared_ptr<Node> condition_node; 
+    const std::shared_ptr<Node>& get_condition() { return condition_node; }
+    const NodeList& get_expr() { return expr_node; }
+    const NodeList& get_else() { return else_node; }
+    std::string get_type() override { return NODE_IF; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return ""; }
+
+   protected:
+    std::shared_ptr<Node> condition_node;
     NodeList expr_node, else_node;
 };
 
-class ForNode: public Node {
-public:
-    ForNode(
-        std::shared_ptr<Node> _var_assign, std::shared_ptr<Node> _end_value,
-        std::shared_ptr<Node> _step_value, NodeList _body_node
-    )   : var_assign(_var_assign), end_value(_end_value), step_value(_step_value), body_node(_body_node) {}
+class ForNode : public Node {
+   public:
+    ForNode(std::shared_ptr<Node> _var_assign, std::shared_ptr<Node> _end_value,
+            std::shared_ptr<Node> _step_value, NodeList _body_node)
+        : var_assign(_var_assign),
+          end_value(_end_value),
+          step_value(_step_value),
+          body_node(_body_node) {}
     std::string get_node() override;
     NodeList get_child() override {
         NodeList child{var_assign, end_value, step_value};
-        for(auto node : body_node) child.push_back(node);
+        for (auto node : body_node) child.push_back(node);
         return child;
     }
-    std::string get_type() override { return NODE_FOR;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return "";}
-protected:
+    std::string get_type() override { return NODE_FOR; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return ""; }
+
+   protected:
     std::shared_ptr<Node> var_assign, end_value, step_value;
     NodeList body_node;
 };
 
-class WhileNode: public Node {
-public:
+class WhileNode : public Node {
+   public:
     WhileNode(std::shared_ptr<Node> _condition, NodeList _body_node)
         : condition(_condition), body_node(_body_node) {}
     std::string get_node() override;
     NodeList get_child() override {
         NodeList child{condition};
-        for(auto node : body_node) child.push_back(node);
+        for (auto node : body_node) child.push_back(node);
         return child;
     }
-    std::string get_type() override { return NODE_WHILE;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return "";}
-protected:
+    std::string get_type() override { return NODE_WHILE; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return ""; }
+
+   protected:
     std::shared_ptr<Node> condition;
     NodeList body_node;
 };
 
-class RepeatNode: public Node {
-public:
+class RepeatNode : public Node {
+   public:
     RepeatNode(NodeList _body_node, std::shared_ptr<Node> _condition)
         : condition(_condition), body_node(_body_node) {}
     std::string get_node() override;
     NodeList get_child() override {
         NodeList child{condition};
-        for(auto node : body_node) child.push_back(node);
+        for (auto node : body_node) child.push_back(node);
         return child;
     }
-    std::string get_type() override { return NODE_REPEAT;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return "";}
-protected:
+    std::string get_type() override { return NODE_REPEAT; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return ""; }
+
+   protected:
     std::shared_ptr<Node> condition;
     NodeList body_node;
 };
 
-class AlgorithmDefNode: public Node {
-public:
-    AlgorithmDefNode(std::shared_ptr<Token> _algo_name, const TokenList &_args_name, NodeList _body_node = {})
+class AlgorithmDefNode : public Node {
+   public:
+    AlgorithmDefNode(std::shared_ptr<Token> _algo_name, const TokenList& _args_name,
+                     NodeList _body_node = {})
         : algo_name(_algo_name), args_name(_args_name), body_node(_body_node) {}
     std::string get_node() override;
-    NodeList get_child() override { return body_node;}
-    const NodeList& get_body() const { return body_node;}
-    std::string get_type() override { return NODE_ALGODEF;}
-    std::shared_ptr<Token> get_tok() override { return algo_name;}
-    TokenList get_toks() override { return args_name;}
-    std::string get_name() override { return algo_name->get_value();}
-protected:
+    NodeList get_child() override { return body_node; }
+    const NodeList& get_body() const { return body_node; }
+    std::string get_type() override { return NODE_ALGODEF; }
+    std::shared_ptr<Token> get_tok() override { return algo_name; }
+    TokenList get_toks() override { return args_name; }
+    std::string get_name() override { return algo_name->get_value(); }
+
+   protected:
     std::shared_ptr<Token> algo_name;
     TokenList args_name;
     NodeList body_node;
 };
 
-class AlgorithmCallNode: public Node {
-public:
-    AlgorithmCallNode(std::shared_ptr<Node> _call_node, const NodeList &_args)
+class AlgorithmCallNode : public Node {
+   public:
+    AlgorithmCallNode(std::shared_ptr<Node> _call_node, const NodeList& _args)
         : call_node(_call_node), args(_args) {}
     std::string get_node() override;
-    NodeList get_child() override { return args;}
-    const NodeList& get_args() const { return args;}
-    std::string get_type() override { return NODE_ALGOCALL;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return call_node->get_name();}
-    std::shared_ptr<Node> get_call() { return call_node;}
-protected:
+    NodeList get_child() override { return args; }
+    const NodeList& get_args() const { return args; }
+    std::string get_type() override { return NODE_ALGOCALL; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return call_node->get_name(); }
+    std::shared_ptr<Node> get_call() { return call_node; }
+
+   protected:
     std::shared_ptr<Node> call_node;
     NodeList args;
 };
 
-class ArrayNode: public Node {
-public:
-    ArrayNode(const NodeList &_elements_node)
-        : elements_node(_elements_node) {}
+class ArrayNode : public Node {
+   public:
+    ArrayNode(const NodeList& _elements_node) : elements_node(_elements_node) {}
     std::string get_node() override;
-    NodeList get_child() override { return elements_node;}
-    std::string get_type() override { return NODE_ARRAY;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return "";}
-protected:
+    NodeList get_child() override { return elements_node; }
+    std::string get_type() override { return NODE_ARRAY; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return ""; }
+
+   protected:
     NodeList elements_node;
 };
 
-class ArrayAccessNode: public Node {
-public:
+class ArrayAccessNode : public Node {
+   public:
     ArrayAccessNode(std::shared_ptr<Node> _arr, std::shared_ptr<Node> _index)
         : arr(_arr), index(_index) {}
     std::string get_node() override;
-    NodeList get_child() override { return NodeList{arr, index};}
-    std::string get_type() override { return NODE_ARRACCESS;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-protected:
+    NodeList get_child() override { return NodeList{arr, index}; }
+    std::string get_type() override { return NODE_ARRACCESS; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+
+   protected:
     std::shared_ptr<Node> arr, index;
 };
 
-class ArrayAssignNode: public Node {
-public:
+class ArrayAssignNode : public Node {
+   public:
     ArrayAssignNode(std::shared_ptr<Node> _arr, std::shared_ptr<Node> _value)
         : arr(_arr), value(_value) {}
     std::string get_node() override;
-    NodeList get_child() override { return NodeList{arr, value};}
-    std::string get_type() override { return NODE_ARRASSIGN;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-protected:
+    NodeList get_child() override { return NodeList{arr, value}; }
+    std::string get_type() override { return NODE_ARRASSIGN; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+
+   protected:
     std::shared_ptr<Node> arr, value;
 };
 
-class MemberAccessNode: public Node {
-public:
+class MemberAccessNode : public Node {
+   public:
     MemberAccessNode(std::shared_ptr<Node> _obj, std::shared_ptr<Node> _member)
         : obj(_obj), member(_member) {}
     std::string get_node() override;
-    NodeList get_child() override { return NodeList{obj, member};}
-    std::string get_type() override { return NODE_MEMACCESS;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-protected:
+    NodeList get_child() override { return NodeList{obj, member}; }
+    std::string get_type() override { return NODE_MEMACCESS; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+
+   protected:
     std::shared_ptr<Node> obj, member;
 };
 
-class StructDefNode: public Node {
-public:
-    StructDefNode(std::shared_ptr<Token> _struct_name, const TokenList &_members, const NodeList &_methods)
+class StructDefNode : public Node {
+   public:
+    StructDefNode(std::shared_ptr<Token> _struct_name, const TokenList& _members,
+                  const NodeList& _methods)
         : struct_name(_struct_name), members(_members), methods(_methods) {}
     std::string get_node() override;
-    NodeList get_child() override { return methods;}
-    std::string get_type() override { return NODE_STRUCTDEF;}
-    std::shared_ptr<Token> get_tok() override { return struct_name;}
-    TokenList get_toks() override { return members;}
-    std::string get_name() override { return struct_name->get_value();}
-protected:
+    NodeList get_child() override { return methods; }
+    std::string get_type() override { return NODE_STRUCTDEF; }
+    std::shared_ptr<Token> get_tok() override { return struct_name; }
+    TokenList get_toks() override { return members; }
+    std::string get_name() override { return struct_name->get_value(); }
+
+   protected:
     std::shared_ptr<Token> struct_name;
     TokenList members;
     NodeList methods;
 };
 
-class ReturnNode: public Node {
-public:
-    ReturnNode(std::shared_ptr<Node> _node)
-        : node(_node) {}
+class ReturnNode : public Node {
+   public:
+    ReturnNode(std::shared_ptr<Node> _node) : node(_node) {}
     std::string get_node() override { return "RETURN " + node->get_node(); }
-    NodeList get_child() override { return NodeList{node};}
-    std::string get_type() override { return NODE_RETURN;}
-    std::shared_ptr<Token> get_tok() override { return nullptr;}
-    std::string get_name() override { return "";}
-protected:
+    NodeList get_child() override { return NodeList{node}; }
+    std::string get_type() override { return NODE_RETURN; }
+    std::shared_ptr<Token> get_tok() override { return nullptr; }
+    std::string get_name() override { return ""; }
+
+   protected:
     std::shared_ptr<Node> node;
 };
 
-class ControlNode: public Node {
-public:
-    ControlNode(const std::string& _type)
-        : control_type(_type) {}
+class ControlNode : public Node {
+   public:
+    ControlNode(const std::string& _type) : control_type(_type) {}
     std::string get_node() override { return control_type; }
     std::string get_type() override { return control_type; }
-protected:
+
+   protected:
     std::string control_type;
 };
 
diff --git a/src/pseudo.cpp b/src/pseudo.cpp
index b4ff492..5cac55c 100644
--- a/src/pseudo.cpp
+++ b/src/pseudo.cpp
@@ -1,11 +1,5 @@
 #include "pseudo.h"
-#include "analysis.h"
-#include "imports.h"
-#include "color.h"
-#include "interpreter.h"
-#include "node.h"
-#include "value.h"
-#include "error.h"
+
 #include <cctype>
 #include <cmath>
 #include <filesystem>
@@ -20,13 +14,21 @@
 #include <unordered_set>
 #include <vector>
 
+#include "analysis.h"
+#include "color.h"
+#include "error.h"
+#include "imports.h"
+#include "interpreter.h"
+#include "node.h"
+#include "value.h"
+
 /// --------------------
 /// Value
 /// --------------------
 
-std::ostream &operator<<(std::ostream &out, Value &number) {
-  out << number.get_num();
-  return out;
+std::ostream& operator<<(std::ostream& out, Value& number) {
+    out << number.get_num();
+    return out;
 }
 
 int64_t Value::as_int() { return std::stoll(get_num()); }
@@ -35,250 +37,249 @@ double Value::as_double() { return std::stod(get_num()); }
 
 std::string Value::as_string() { return get_num(); }
 
-template <typename T> std::string TypedValue<T>::get_num() {
-  std::stringstream ss;
-  std::string ret;
-  if (type == VALUE_FLOAT || type == VALUE_INT) {
-    ss << value;
-    std::getline(ss, ret);
-  } else if (type == VALUE_STRING || type == VALUE_ERROR) {
-    ret = value;
-  }
-  return ret;
+template <typename T>
+std::string TypedValue<T>::get_num() {
+    std::stringstream ss;
+    std::string ret;
+    if (type == VALUE_FLOAT || type == VALUE_INT) {
+        ss << value;
+        std::getline(ss, ret);
+    } else if (type == VALUE_STRING || type == VALUE_ERROR) {
+        ret = value;
+    }
+    return ret;
 }
 
-template <typename T> int64_t TypedValue<T>::as_int() {
-  if constexpr (std::is_same_v<T, int64_t>) {
-    return value;
-  } else if constexpr (std::is_same_v<T, double>) {
-    return static_cast<int64_t>(value);
-  } else {
-    return std::stoll(value);
-  }
+template <typename T>
+int64_t TypedValue<T>::as_int() {
+    if constexpr (std::is_same_v<T, int64_t>) {
+        return value;
+    } else if constexpr (std::is_same_v<T, double>) {
+        return static_cast<int64_t>(value);
+    } else {
+        return std::stoll(value);
+    }
 }
 
-template <typename T> double TypedValue<T>::as_double() {
-  if constexpr (std::is_same_v<T, double>) {
-    return value;
-  } else if constexpr (std::is_same_v<T, int64_t>) {
-    return static_cast<double>(value);
-  } else {
-    return std::stod(value);
-  }
+template <typename T>
+double TypedValue<T>::as_double() {
+    if constexpr (std::is_same_v<T, double>) {
+        return value;
+    } else if constexpr (std::is_same_v<T, int64_t>) {
+        return static_cast<double>(value);
+    } else {
+        return std::stod(value);
+    }
 }
 
-template <typename T> std::string TypedValue<T>::as_string() {
-  if constexpr (std::is_same_v<T, std::string>) {
-    return value;
-  } else {
-    return get_num();
-  }
+template <typename T>
+std::string TypedValue<T>::as_string() {
+    if constexpr (std::is_same_v<T, std::string>) {
+        return value;
+    } else {
+        return get_num();
+    }
 }
 
-template <typename T> bool TypedValue<T>::append_string(const std::string& suffix) {
-  if constexpr (std::is_same_v<T, std::string>) {
-    value += suffix;
-    return true;
-  }
-  return false;
-}
-
-template <typename T> std::string TypedValue<T>::repr() {
-  std::stringstream ss;
-  std::string ret;
-  if (type == VALUE_FLOAT || type == VALUE_INT) {
-    ret = get_num();
-  } else if (type == VALUE_STRING) {
-    ss << value;
-
-    char ch{char(ss.get())};
-    ret += '\"';
-    while (!ss.eof()) {
-      if (REVERSE_ESCAPE_CHAR.count(ch)) {
-        ret += '\\';
-        ret += REVERSE_ESCAPE_CHAR.at(ch);
-      } else {
-        ret += ch;
-      }
-      ch = ss.get();
-    }
-    ret += '\"';
-  }
-  return ret;
+template <typename T>
+bool TypedValue<T>::append_string(const std::string& suffix) {
+    if constexpr (std::is_same_v<T, std::string>) {
+        value += suffix;
+        return true;
+    }
+    return false;
 }
 
-std::string ArrayValue::get_num() {
-  std::stringstream ss;
-  ss << "{";
-  if (!value.empty())
-    ss << value[0]->repr();
-  for (int i{1}; i < value.size(); ++i) {
-    ss << ", " << value[i]->repr();
-  }
-  ss << "}";
-  std::string ret;
-  std::getline(ss, ret);
-  return ret;
+template <typename T>
+std::string TypedValue<T>::repr() {
+    std::stringstream ss;
+    std::string ret;
+    if (type == VALUE_FLOAT || type == VALUE_INT) {
+        ret = get_num();
+    } else if (type == VALUE_STRING) {
+        ss << value;
+
+        char ch{char(ss.get())};
+        ret += '\"';
+        while (!ss.eof()) {
+            if (REVERSE_ESCAPE_CHAR.count(ch)) {
+                ret += '\\';
+                ret += REVERSE_ESCAPE_CHAR.at(ch);
+            } else {
+                ret += ch;
+            }
+            ch = ss.get();
+        }
+        ret += '\"';
+    }
+    return ret;
 }
 
-void ArrayValue::push_back(std::shared_ptr<Value> new_value) {
-  value.push_back(new_value);
+std::string ArrayValue::get_num() {
+    std::stringstream ss;
+    ss << "{";
+    if (!value.empty()) ss << value[0]->repr();
+    for (int i{1}; i < value.size(); ++i) {
+        ss << ", " << value[i]->repr();
+    }
+    ss << "}";
+    std::string ret;
+    std::getline(ss, ret);
+    return ret;
 }
 
+void ArrayValue::push_back(std::shared_ptr<Value> new_value) { value.push_back(new_value); }
+
 std::shared_ptr<Value> ArrayValue::insert(int p, std::shared_ptr<Value> new_value) {
-  if (p < 1 || p > static_cast<int>(value.size()) + 1) {
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR, "Index out of range, size: " + std::to_string(value.size()) +
-                         ", position: " + std::to_string(p));
-  }
-  value.insert(value.begin() + (p - 1), new_value);
-  return new_value;
+    if (p < 1 || p > static_cast<int>(value.size()) + 1) {
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, "Index out of range, size: " + std::to_string(value.size()) +
+                             ", position: " + std::to_string(p));
+    }
+    value.insert(value.begin() + (p - 1), new_value);
+    return new_value;
 }
 
 std::shared_ptr<Value> ArrayValue::remove(int p) {
-  if (p < 1 || p > static_cast<int>(value.size())) {
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR, "Index out of range, size: " + std::to_string(value.size()) +
-                         ", position: " + std::to_string(p));
-  }
-  std::shared_ptr<Value> ret = value[p - 1];
-  value.erase(value.begin() + (p - 1));
-  return ret;
+    if (p < 1 || p > static_cast<int>(value.size())) {
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, "Index out of range, size: " + std::to_string(value.size()) +
+                             ", position: " + std::to_string(p));
+    }
+    std::shared_ptr<Value> ret = value[p - 1];
+    value.erase(value.begin() + (p - 1));
+    return ret;
 }
 
 std::shared_ptr<Value> ArrayValue::pop_back() {
-  if (value.empty())
-    return std::make_shared<ErrorValue>(VALUE_ERROR, "Pop an empty array");
-  std::shared_ptr<Value> ret = value.back();
-  value.pop_back();
-  return ret;
+    if (value.empty()) return std::make_shared<ErrorValue>(VALUE_ERROR, "Pop an empty array");
+    std::shared_ptr<Value> ret = value.back();
+    value.pop_back();
+    return ret;
 }
 
-std::shared_ptr<Value> &ArrayValue::operator[](int p) {
-  if (1 <= p && p <= value.size())
-    return value[p - 1];
-  error = std::make_shared<ErrorValue>(
-      VALUE_ERROR, "Index out of range, size: " + std::to_string(value.size()) +
-                       ", position: " + std::to_string(p));
-  return error;
+std::shared_ptr<Value>& ArrayValue::operator[](int p) {
+    if (1 <= p && p <= value.size()) return value[p - 1];
+    error = std::make_shared<ErrorValue>(
+        VALUE_ERROR, "Index out of range, size: " + std::to_string(value.size()) +
+                         ", position: " + std::to_string(p));
+    return error;
 }
 
 std::string HashTableValue::key_id(std::shared_ptr<Value> key) const {
-  if (key->get_type() == VALUE_ARRAY || key->get_type() == VALUE_INSTANCE ||
-      key->get_type() == VALUE_STRUCT || key->get_type() == VALUE_HASH_TABLE ||
-      key->get_type() == VALUE_ALGO) {
-    return key->get_type() + ":ptr:" +
-           std::to_string(reinterpret_cast<std::uintptr_t>(key.get()));
-  }
-  return key->get_type() + ":" + key->repr();
+    if (key->get_type() == VALUE_ARRAY || key->get_type() == VALUE_INSTANCE ||
+        key->get_type() == VALUE_STRUCT || key->get_type() == VALUE_HASH_TABLE ||
+        key->get_type() == VALUE_ALGO) {
+        return key->get_type() +
+               ":ptr:" + std::to_string(reinterpret_cast<std::uintptr_t>(key.get()));
+    }
+    return key->get_type() + ":" + key->repr();
 }
 
 std::string HashTableValue::get_num() {
-  std::stringstream ss;
-  ss << "{";
-  if (!entries.empty()) {
-    ss << entries[0].key->repr() << ": " << entries[0].value->repr();
-  }
-  for (size_t i = 1; i < entries.size(); ++i) {
-    ss << ", " << entries[i].key->repr() << ": " << entries[i].value->repr();
-  }
-  ss << "}";
-  return ss.str();
+    std::stringstream ss;
+    ss << "{";
+    if (!entries.empty()) {
+        ss << entries[0].key->repr() << ": " << entries[0].value->repr();
+    }
+    for (size_t i = 1; i < entries.size(); ++i) {
+        ss << ", " << entries[i].key->repr() << ": " << entries[i].value->repr();
+    }
+    ss << "}";
+    return ss.str();
 }
 
 std::shared_ptr<Value> HashTableValue::get(std::shared_ptr<Value> key) {
-  auto found = index.find(key_id(key));
-  if (found == index.end()) {
-    return std::make_shared<Value>();
-  }
-  return entries[found->second].value;
+    auto found = index.find(key_id(key));
+    if (found == index.end()) {
+        return std::make_shared<Value>();
+    }
+    return entries[found->second].value;
 }
 
 std::shared_ptr<Value> HashTableValue::set(std::shared_ptr<Value> key,
                                            std::shared_ptr<Value> value) {
-  std::string id = key_id(key);
-  auto found = index.find(id);
-  if (found != index.end()) {
-    entries[found->second].value = value;
+    std::string id = key_id(key);
+    auto found = index.find(id);
+    if (found != index.end()) {
+        entries[found->second].value = value;
+        return value;
+    }
+    index[id] = entries.size();
+    entries.push_back({key, value});
     return value;
-  }
-  index[id] = entries.size();
-  entries.push_back({key, value});
-  return value;
 }
 
 std::shared_ptr<Value> HashTableValue::remove(std::shared_ptr<Value> key) {
-  std::string id = key_id(key);
-  auto found = index.find(id);
-  if (found == index.end()) {
-    return std::make_shared<Value>();
-  }
+    std::string id = key_id(key);
+    auto found = index.find(id);
+    if (found == index.end()) {
+        return std::make_shared<Value>();
+    }
 
-  size_t removed = found->second;
-  std::shared_ptr<Value> value = entries[removed].value;
-  index.erase(found);
-  if (removed != entries.size() - 1) {
-    entries[removed] = entries.back();
-    index[key_id(entries[removed].key)] = removed;
-  }
-  entries.pop_back();
-  return value;
+    size_t removed = found->second;
+    std::shared_ptr<Value> value = entries[removed].value;
+    index.erase(found);
+    if (removed != entries.size() - 1) {
+        entries[removed] = entries.back();
+        index[key_id(entries[removed].key)] = removed;
+    }
+    entries.pop_back();
+    return value;
 }
 
 bool HashTableValue::contains(std::shared_ptr<Value> key) const {
-  return index.count(key_id(key)) != 0;
+    return index.count(key_id(key)) != 0;
 }
 
 std::shared_ptr<Value> HashTableValue::size() const {
-  return std::make_shared<TypedValue<int64_t>>(VALUE_INT, entries.size());
+    return std::make_shared<TypedValue<int64_t>>(VALUE_INT, entries.size());
 }
 
 std::shared_ptr<Value> HashTableValue::keys() const {
-  ValueList keys;
-  keys.reserve(entries.size());
-  for (const Entry& entry : entries) {
-    keys.push_back(entry.key);
-  }
-  return std::make_shared<ArrayValue>(keys);
+    ValueList keys;
+    keys.reserve(entries.size());
+    for (const Entry& entry : entries) {
+        keys.push_back(entry.key);
+    }
+    return std::make_shared<ArrayValue>(keys);
 }
 
 std::shared_ptr<Value> HashTableValue::values() const {
-  ValueList values;
-  values.reserve(entries.size());
-  for (const Entry& entry : entries) {
-    values.push_back(entry.value);
-  }
-  return std::make_shared<ArrayValue>(values);
+    ValueList values;
+    values.reserve(entries.size());
+    for (const Entry& entry : entries) {
+        values.push_back(entry.value);
+    }
+    return std::make_shared<ArrayValue>(values);
 }
 
 void HashTableValue::clear() {
-  entries.clear();
-  index.clear();
+    entries.clear();
+    index.clear();
 }
 
-std::shared_ptr<Value> BaseAlgoValue::set_args(const NodeList &args, SymbolTable &sym,
-                                               Interpreter &interpreter) {
-  if (args.size() < arg_names.size()) {
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too few arguments" RESET);
-  } else if (args.size() > arg_names.size()) {
-    return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                        Color(0xFF, 0x39, 0x6E).get() +
-                                            "Too many arguments" RESET);
-  }
-
-  for (int i = 0; i < args.size(); ++i) {
-    std::shared_ptr<Value> v = interpreter.visit(args[i]);
-    if (v->get_type() == VALUE_ERROR)
-      return v;
-    sym.set(arg_names[i], v);
-  }
-  static std::shared_ptr<Value> none = std::make_shared<Value>();
-  return none;
+std::shared_ptr<Value> BaseAlgoValue::set_args(const NodeList& args, SymbolTable& sym,
+                                               Interpreter& interpreter) {
+    if (args.size() < arg_names.size()) {
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too few arguments" RESET);
+    } else if (args.size() > arg_names.size()) {
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too many arguments" RESET);
+    }
+
+    for (int i = 0; i < args.size(); ++i) {
+        std::shared_ptr<Value> v = interpreter.visit(args[i]);
+        if (v->get_type() == VALUE_ERROR) return v;
+        sym.set(arg_names[i], v);
+    }
+    static std::shared_ptr<Value> none = std::make_shared<Value>();
+    return none;
 }
 
 class ScopeCleaner {
-public:
+   public:
     ScopeCleaner(SymbolTable& _sym) : sym(_sym) {}
     ~ScopeCleaner() {
         if (!sym.has_instances()) {
@@ -291,134 +292,117 @@ class ScopeCleaner {
                     std::shared_ptr<Value> self_ptr = val;
                     std::shared_ptr<Value> dtor = inst->get_member("destructor", self_ptr);
                     if (dtor->get_type() == VALUE_ALGO) {
-                         dtor->execute({}, sym.get_parent());
+                        dtor->execute({}, sym.get_parent());
                     }
                 }
             }
         }
     }
-private:
+
+   private:
     SymbolTable& sym;
 };
 
 namespace {
 
-bool is_pure_numeric_node(const std::shared_ptr<Node>& node,
-                          const std::string& algo_name,
+bool is_pure_numeric_node(const std::shared_ptr<Node>& node, const std::string& algo_name,
                           const std::unordered_set<std::string>& arg_names) {
-  if (!node)
-    return false;
+    if (!node) return false;
 
-  const std::string type = node->get_type();
-  if (type == NODE_VALUE) {
-    const std::string token_type = node->get_tok()->get_type();
-    return token_type == TOKEN_INT || token_type == TOKEN_FLOAT;
-  }
-  if (type == NODE_VARACCESS) {
-    return arg_names.count(node->get_name()) != 0;
-  }
-  if (type == NODE_BINOP) {
-    NodeList child = node->get_child();
-    return child.size() == 2 &&
-           is_pure_numeric_node(child[0], algo_name, arg_names) &&
-           is_pure_numeric_node(child[1], algo_name, arg_names);
-  }
-  if (type == NODE_UNARYOP) {
-    NodeList child = node->get_child();
-    return child.size() == 1 &&
-           is_pure_numeric_node(child[0], algo_name, arg_names);
-  }
-  if (type == NODE_RETURN) {
-    NodeList child = node->get_child();
-    return child.size() == 1 &&
-           is_pure_numeric_node(child[0], algo_name, arg_names);
-  }
-  if (type == NODE_IF) {
-    IfNode* if_node = dynamic_cast<IfNode*>(node.get());
-    if (!is_pure_numeric_node(if_node->get_condition(), algo_name, arg_names))
-      return false;
-    for (const auto& expr : if_node->get_expr()) {
-      if (!is_pure_numeric_node(expr, algo_name, arg_names))
-        return false;
+    const std::string type = node->get_type();
+    if (type == NODE_VALUE) {
+        const std::string token_type = node->get_tok()->get_type();
+        return token_type == TOKEN_INT || token_type == TOKEN_FLOAT;
     }
-    for (const auto& expr : if_node->get_else()) {
-      if (!is_pure_numeric_node(expr, algo_name, arg_names))
-        return false;
+    if (type == NODE_VARACCESS) {
+        return arg_names.count(node->get_name()) != 0;
     }
-    return true;
-  }
-  if (type == NODE_ALGOCALL) {
-    AlgorithmCallNode* call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
-    if (call_node->get_call()->get_type() != NODE_VARACCESS ||
-        call_node->get_name() != algo_name) {
-      return false;
-    }
-    for (const auto& arg : call_node->get_args()) {
-      if (!is_pure_numeric_node(arg, algo_name, arg_names))
-        return false;
+    if (type == NODE_BINOP) {
+        NodeList child = node->get_child();
+        return child.size() == 2 && is_pure_numeric_node(child[0], algo_name, arg_names) &&
+               is_pure_numeric_node(child[1], algo_name, arg_names);
+    }
+    if (type == NODE_UNARYOP) {
+        NodeList child = node->get_child();
+        return child.size() == 1 && is_pure_numeric_node(child[0], algo_name, arg_names);
+    }
+    if (type == NODE_RETURN) {
+        NodeList child = node->get_child();
+        return child.size() == 1 && is_pure_numeric_node(child[0], algo_name, arg_names);
+    }
+    if (type == NODE_IF) {
+        IfNode* if_node = dynamic_cast<IfNode*>(node.get());
+        if (!is_pure_numeric_node(if_node->get_condition(), algo_name, arg_names)) return false;
+        for (const auto& expr : if_node->get_expr()) {
+            if (!is_pure_numeric_node(expr, algo_name, arg_names)) return false;
+        }
+        for (const auto& expr : if_node->get_else()) {
+            if (!is_pure_numeric_node(expr, algo_name, arg_names)) return false;
+        }
+        return true;
+    }
+    if (type == NODE_ALGOCALL) {
+        AlgorithmCallNode* call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
+        if (call_node->get_call()->get_type() != NODE_VARACCESS ||
+            call_node->get_name() != algo_name) {
+            return false;
+        }
+        for (const auto& arg : call_node->get_args()) {
+            if (!is_pure_numeric_node(arg, algo_name, arg_names)) return false;
+        }
+        return true;
     }
-    return true;
-  }
 
-  return false;
+    return false;
 }
 
 bool has_self_call(const std::shared_ptr<Node>& node, const std::string& algo_name) {
-  if (!node)
-    return false;
+    if (!node) return false;
 
-  if (node->get_type() == NODE_ALGOCALL) {
-    AlgorithmCallNode* call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
-    if (call_node->get_call()->get_type() == NODE_VARACCESS &&
-        call_node->get_name() == algo_name) {
-      return true;
-    }
-    for (const auto& arg : call_node->get_args()) {
-      if (has_self_call(arg, algo_name))
-        return true;
+    if (node->get_type() == NODE_ALGOCALL) {
+        AlgorithmCallNode* call_node = dynamic_cast<AlgorithmCallNode*>(node.get());
+        if (call_node->get_call()->get_type() == NODE_VARACCESS &&
+            call_node->get_name() == algo_name) {
+            return true;
+        }
+        for (const auto& arg : call_node->get_args()) {
+            if (has_self_call(arg, algo_name)) return true;
+        }
+        return false;
     }
-    return false;
-  }
-
-  if (node->get_type() == NODE_IF) {
-    IfNode* if_node = dynamic_cast<IfNode*>(node.get());
-    if (has_self_call(if_node->get_condition(), algo_name))
-      return true;
-    for (const auto& expr : if_node->get_expr()) {
-      if (has_self_call(expr, algo_name))
-        return true;
+
+    if (node->get_type() == NODE_IF) {
+        IfNode* if_node = dynamic_cast<IfNode*>(node.get());
+        if (has_self_call(if_node->get_condition(), algo_name)) return true;
+        for (const auto& expr : if_node->get_expr()) {
+            if (has_self_call(expr, algo_name)) return true;
+        }
+        for (const auto& expr : if_node->get_else()) {
+            if (has_self_call(expr, algo_name)) return true;
+        }
+        return false;
     }
-    for (const auto& expr : if_node->get_else()) {
-      if (has_self_call(expr, algo_name))
-        return true;
+
+    for (const auto& child : node->get_child()) {
+        if (has_self_call(child, algo_name)) return true;
     }
     return false;
-  }
-
-  for (const auto& child : node->get_child()) {
-    if (has_self_call(child, algo_name))
-      return true;
-  }
-  return false;
 }
 
-} // namespace
+}  // namespace
 
-bool is_memoizable_numeric_algo(const std::shared_ptr<Node>& node,
-                                const std::string& algo_name,
+bool is_memoizable_numeric_algo(const std::shared_ptr<Node>& node, const std::string& algo_name,
                                 const std::vector<std::string>& args) {
-  AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(node.get());
-  if (!algo_node || args.empty())
-    return false;
-
-  bool recursive = false;
-  std::unordered_set<std::string> arg_set(args.begin(), args.end());
-  for (const auto& expr : algo_node->get_body()) {
-    if (!is_pure_numeric_node(expr, algo_name, arg_set))
-      return false;
-    recursive = recursive || has_self_call(expr, algo_name);
-  }
-  return recursive;
+    AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(node.get());
+    if (!algo_node || args.empty()) return false;
+
+    bool recursive = false;
+    std::unordered_set<std::string> arg_set(args.begin(), args.end());
+    for (const auto& expr : algo_node->get_body()) {
+        if (!is_pure_numeric_node(expr, algo_name, arg_set)) return false;
+        recursive = recursive || has_self_call(expr, algo_name);
+    }
+    return recursive;
 }
 
 namespace {
@@ -426,784 +410,692 @@ namespace {
 std::shared_ptr<Node> single_return_numeric_expr(const std::shared_ptr<Node>& node,
                                                  const std::string& algo_name,
                                                  const std::vector<std::string>& args) {
-  AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(node.get());
-  if (!algo_node || algo_node->get_body().size() != 1)
-    return nullptr;
+    AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(node.get());
+    if (!algo_node || algo_node->get_body().size() != 1) return nullptr;
 
-  std::shared_ptr<Node> ret = algo_node->get_body()[0];
-  if (ret->get_type() != NODE_RETURN || has_self_call(ret, algo_name))
-    return nullptr;
+    std::shared_ptr<Node> ret = algo_node->get_body()[0];
+    if (ret->get_type() != NODE_RETURN || has_self_call(ret, algo_name)) return nullptr;
 
-  NodeList child = ret->get_child();
-  if (child.size() != 1)
-    return nullptr;
+    NodeList child = ret->get_child();
+    if (child.size() != 1) return nullptr;
 
-  std::unordered_set<std::string> arg_set(args.begin(), args.end());
-  if (!is_pure_numeric_node(child[0], algo_name, arg_set))
-    return nullptr;
-  return child[0];
+    std::unordered_set<std::string> arg_set(args.begin(), args.end());
+    if (!is_pure_numeric_node(child[0], algo_name, arg_set)) return nullptr;
+    return child[0];
 }
 
 std::string numeric_cache_key(const ValueList& values) {
-  std::string key;
-  for (const auto& value : values) {
-    if (value->get_type() != VALUE_INT && value->get_type() != VALUE_FLOAT)
-      return "";
-    key += value->get_type();
-    key += ':';
-    key += value->get_num();
-    key += '|';
-  }
-  return key;
-}
-
-} // namespace
-
-std::shared_ptr<Value> AlgoValue::execute(const NodeList& args, SymbolTable *parent) {
-  static std::unordered_map<std::size_t, bool> memoizable_by_node;
-  static std::unordered_map<std::size_t,
-      std::unordered_map<std::string, std::shared_ptr<Value>>> memoized_results;
-  static std::unordered_map<std::size_t, JitProgram> single_return_jit;
-  static std::unordered_set<std::size_t> single_return_jit_disabled;
-
-  SymbolTable sym(parent);
-  ScopeCleaner cleaner(sym);
-  Interpreter interpreter(sym);
-  const std::size_t node_id = value->get_id();
-  auto memoizable_found = memoizable_by_node.find(node_id);
-  if (memoizable_found == memoizable_by_node.end()) {
-    memoizable_found = memoizable_by_node.emplace(
-        node_id, is_memoizable_numeric_algo(value, algo_name, arg_names)).first;
-  }
-
-  if (memoizable_found->second) {
-    if (args.size() < arg_names.size()) {
-      return std::make_shared<ErrorValue>(
-          VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too few arguments" RESET);
-    } else if (args.size() > arg_names.size()) {
-      return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                          Color(0xFF, 0x39, 0x6E).get() +
-                                              "Too many arguments" RESET);
+    std::string key;
+    for (const auto& value : values) {
+        if (value->get_type() != VALUE_INT && value->get_type() != VALUE_FLOAT) return "";
+        key += value->get_type();
+        key += ':';
+        key += value->get_num();
+        key += '|';
     }
+    return key;
+}
 
-    ValueList evaluated_args;
-    evaluated_args.reserve(args.size());
-    for (int i = 0; i < args.size(); ++i) {
-      std::shared_ptr<Value> arg = interpreter.visit(args[i]);
-      if (arg->get_type() == VALUE_ERROR)
-        return arg;
-      evaluated_args.push_back(arg);
-    }
-
-    const std::string cache_key = numeric_cache_key(evaluated_args);
-    if (!cache_key.empty()) {
-      auto& cache = memoized_results[node_id];
-      auto cached = cache.find(cache_key);
-      if (cached != cache.end()) {
-        return cached->second;
-      }
-
-      for (int i = 0; i < evaluated_args.size(); ++i) {
-        sym.set(arg_names[i], evaluated_args[i]);
-      }
-
-      AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(value.get());
-      const NodeList& algo_body = algo_node->get_body();
-      std::shared_ptr<Value> ret = std::make_shared<Value>();
-      for (int i = 0; i < algo_body.size(); ++i) {
-        ret = interpreter.visit(algo_body[i]);
-        if (ret->get_type() == VALUE_RETURN) {
-          ret = dynamic_cast<ReturnValue*>(ret.get())->get_value();
-          break;
+}  // namespace
+
+std::shared_ptr<Value> AlgoValue::execute(const NodeList& args, SymbolTable* parent) {
+    static std::unordered_map<std::size_t, bool> memoizable_by_node;
+    static std::unordered_map<std::size_t, std::unordered_map<std::string, std::shared_ptr<Value>>>
+        memoized_results;
+    static std::unordered_map<std::size_t, JitProgram> single_return_jit;
+    static std::unordered_set<std::size_t> single_return_jit_disabled;
+
+    SymbolTable sym(parent);
+    ScopeCleaner cleaner(sym);
+    Interpreter interpreter(sym);
+    const std::size_t node_id = value->get_id();
+    auto memoizable_found = memoizable_by_node.find(node_id);
+    if (memoizable_found == memoizable_by_node.end()) {
+        memoizable_found =
+            memoizable_by_node
+                .emplace(node_id, is_memoizable_numeric_algo(value, algo_name, arg_names))
+                .first;
+    }
+
+    if (memoizable_found->second) {
+        if (args.size() < arg_names.size()) {
+            return std::make_shared<ErrorValue>(
+                VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too few arguments" RESET);
+        } else if (args.size() > arg_names.size()) {
+            return std::make_shared<ErrorValue>(
+                VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too many arguments" RESET);
         }
-        if (ret->get_type() == VALUE_ERROR) {
-          return ret;
+
+        ValueList evaluated_args;
+        evaluated_args.reserve(args.size());
+        for (int i = 0; i < args.size(); ++i) {
+            std::shared_ptr<Value> arg = interpreter.visit(args[i]);
+            if (arg->get_type() == VALUE_ERROR) return arg;
+            evaluated_args.push_back(arg);
         }
-      }
-      if (ret->get_type() == VALUE_INT || ret->get_type() == VALUE_FLOAT) {
-        cache[cache_key] = ret;
-      }
-      return ret;
-    }
-  }
 
-  std::shared_ptr<Value> ret{set_args(args, sym, interpreter)};
-  if (ret->get_type() == VALUE_ERROR)
-    return ret;
+        const std::string cache_key = numeric_cache_key(evaluated_args);
+        if (!cache_key.empty()) {
+            auto& cache = memoized_results[node_id];
+            auto cached = cache.find(cache_key);
+            if (cached != cache.end()) {
+                return cached->second;
+            }
+
+            for (int i = 0; i < evaluated_args.size(); ++i) {
+                sym.set(arg_names[i], evaluated_args[i]);
+            }
 
-  if (!single_return_jit_disabled.count(node_id)) {
-    auto compiled = single_return_jit.find(node_id);
-    if (compiled == single_return_jit.end()) {
-      std::shared_ptr<Node> return_expr =
-          single_return_numeric_expr(value, algo_name, arg_names);
-      if (return_expr) {
-        std::optional<JitProgram> program = ExpressionJit::compile(return_expr);
-        if (program) {
-          compiled = single_return_jit.emplace(node_id, std::move(*program)).first;
-        } else {
-          single_return_jit_disabled.insert(node_id);
+            AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(value.get());
+            const NodeList& algo_body = algo_node->get_body();
+            std::shared_ptr<Value> ret = std::make_shared<Value>();
+            for (int i = 0; i < algo_body.size(); ++i) {
+                ret = interpreter.visit(algo_body[i]);
+                if (ret->get_type() == VALUE_RETURN) {
+                    ret = dynamic_cast<ReturnValue*>(ret.get())->get_value();
+                    break;
+                }
+                if (ret->get_type() == VALUE_ERROR) {
+                    return ret;
+                }
+            }
+            if (ret->get_type() == VALUE_INT || ret->get_type() == VALUE_FLOAT) {
+                cache[cache_key] = ret;
+            }
+            return ret;
         }
-      } else {
-        single_return_jit_disabled.insert(node_id);
-      }
     }
-    if (compiled != single_return_jit.end()) {
-      std::optional<std::shared_ptr<Value>> jit_result = compiled->second.execute(sym);
-      if (jit_result) {
-        return *jit_result;
-      }
+
+    std::shared_ptr<Value> ret{set_args(args, sym, interpreter)};
+    if (ret->get_type() == VALUE_ERROR) return ret;
+
+    if (!single_return_jit_disabled.count(node_id)) {
+        auto compiled = single_return_jit.find(node_id);
+        if (compiled == single_return_jit.end()) {
+            std::shared_ptr<Node> return_expr =
+                single_return_numeric_expr(value, algo_name, arg_names);
+            if (return_expr) {
+                std::optional<JitProgram> program = ExpressionJit::compile(return_expr);
+                if (program) {
+                    compiled = single_return_jit.emplace(node_id, std::move(*program)).first;
+                } else {
+                    single_return_jit_disabled.insert(node_id);
+                }
+            } else {
+                single_return_jit_disabled.insert(node_id);
+            }
+        }
+        if (compiled != single_return_jit.end()) {
+            std::optional<std::shared_ptr<Value>> jit_result = compiled->second.execute(sym);
+            if (jit_result) {
+                return *jit_result;
+            }
+        }
     }
-  }
 
-  AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(value.get());
-  const NodeList& algo_body = algo_node->get_body();
+    AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(value.get());
+    const NodeList& algo_body = algo_node->get_body();
 
-  for (int i = 0; i < algo_body.size(); ++i) {
-    ret = interpreter.visit(algo_body[i]);
-    if (ret->get_type() == VALUE_RETURN) {
-        return dynamic_cast<ReturnValue*>(ret.get())->get_value();
+    for (int i = 0; i < algo_body.size(); ++i) {
+        ret = interpreter.visit(algo_body[i]);
+        if (ret->get_type() == VALUE_RETURN) {
+            return dynamic_cast<ReturnValue*>(ret.get())->get_value();
+        }
     }
-  }
-  return ret;
+    return ret;
 }
 
-std::shared_ptr<Value> BuiltinAlgoValue::execute(const NodeList& args,
-                                                 SymbolTable *parent) {
-  SymbolTable sym(parent);
-  ScopeCleaner cleaner(sym);
-  Interpreter interpreter(sym);
-  if (algo_name == "print") {
-    std::string output;
-    for (int i = 0; i < args.size(); ++i) {
-      std::shared_ptr<Value> arg = interpreter.visit(args[i]);
-      if (arg->get_type() == VALUE_ERROR)
-        return arg;
-      if (i > 0)
-        output += " ";
-      output += arg->get_num();
-    }
-    return execute_print(output);
-  }
-
-  std::shared_ptr<Value> ret{set_args(args, sym, interpreter)};
-  if (ret->get_type() == VALUE_ERROR)
-    return ret;
-  if (algo_name == "read") {
-    return execute_read();
-  } else if (algo_name == "read_line") {
-    return execute_read_line();
-  } else if (algo_name == "open") {
-    return std::make_shared<ErrorValue>(VALUE_ERROR, "Not found!");
-  } else if (algo_name == "clear") {
-    return execute_clear();
-  } else if (algo_name == "quit") {
-    exit(0);
-  } else if (algo_name == "int") {
-    return execute_int(sym.get(arg_names[0])->get_num());
-  } else if (algo_name == "float") {
-    return execute_float(sym.get(arg_names[0])->get_num());
-  } else if (algo_name == "string") {
-    return execute_string(sym.get(arg_names[0])->get_num());
-  } else if (algo_name == "HashTable") {
-    return std::make_shared<HashTableValue>();
-  }
-  return ret;
-}
-
-std::shared_ptr<Value> BoundMethodValue::execute(const NodeList& args,
-                                                 SymbolTable *parent) {
-  if (obj->get_type() == VALUE_ARRAY) {
-    ArrayValue *arr_obj = dynamic_cast<ArrayValue *>(obj.get());
+std::shared_ptr<Value> BuiltinAlgoValue::execute(const NodeList& args, SymbolTable* parent) {
     SymbolTable sym(parent);
+    ScopeCleaner cleaner(sym);
     Interpreter interpreter(sym);
+    if (algo_name == "print") {
+        std::string output;
+        for (int i = 0; i < args.size(); ++i) {
+            std::shared_ptr<Value> arg = interpreter.visit(args[i]);
+            if (arg->get_type() == VALUE_ERROR) return arg;
+            if (i > 0) output += " ";
+            output += arg->get_num();
+        }
+        return execute_print(output);
+    }
 
-    if (method_name == "push" || method_name == "push_back") {
-      if (args.size() != 1) {
-        return std::make_shared<ErrorValue>(
-            VALUE_ERROR, "Expect one argument for " + method_name + "\n");
-      }
-      std::shared_ptr<Value> arg = interpreter.visit(args[0]);
-      if (arg->get_type() == VALUE_ERROR)
-        return arg;
-      arr_obj->push_back(arg);
-      return arr_obj->back();
-    } else if (method_name == "pop" || method_name == "pop_back") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(
-            VALUE_ERROR, "Expect zero argument for " + method_name + "\n");
-      }
-      if (arr_obj->size()->get_num() == "0") {
-        std::cout << "Cannot " << method_name << " from an empty array\n";
-        return std::make_shared<Value>();
-      }
-      return arr_obj->pop_back();
-    } else if (method_name == "resize") {
-      if (args.size() != 1) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect one argument for resize\n");
-      }
-      std::shared_ptr<Value> new_size_val = interpreter.visit(args[0]);
-      if (new_size_val->get_type() == VALUE_ERROR)
-        return new_size_val;
-      if (new_size_val->get_type() != VALUE_INT) {
-        std::cout << "Argument for resize must be an integer\n";
-        return std::make_shared<Value>();
-      }
-      long long new_size;
-      try {
-        new_size = new_size_val->as_int();
-      } catch (const std::out_of_range &oor) {
-        std::cout << "Resize argument out of range\n";
-        return std::make_shared<Value>();
-      }
-      if (new_size < 0) {
-        std::cout << "Resize argument cannot be negative\n";
-        return std::make_shared<Value>();
-      }
-      arr_obj->resize(static_cast<int>(new_size));
-      return obj;
-    } else if (method_name == "insert") {
-      if (args.size() != 2) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect two arguments for insert\n");
-      }
-      std::shared_ptr<Value> index = interpreter.visit(args[0]);
-      if (index->get_type() == VALUE_ERROR)
-        return index;
-      std::shared_ptr<Value> value = interpreter.visit(args[1]);
-      if (value->get_type() == VALUE_ERROR)
-        return value;
-      return arr_obj->insert(index->as_int(), value);
-    } else if (method_name == "remove") {
-      if (args.size() != 1) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect one argument for remove\n");
-      }
-      std::shared_ptr<Value> index = interpreter.visit(args[0]);
-      if (index->get_type() == VALUE_ERROR)
-        return index;
-      return arr_obj->remove(index->as_int());
-    } else if (method_name == "size") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect zero argument for size\n");
-      }
-      return arr_obj->size();
-    } else if (method_name == "back") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect zero arguments for back\n");
-      }
-      if (arr_obj->size()->get_num() == "0") {
-        return std::make_shared<ErrorValue>(
-            VALUE_ERROR, "Cannot call back on an empty array\n");
-      }
-      return arr_obj->back();
+    std::shared_ptr<Value> ret{set_args(args, sym, interpreter)};
+    if (ret->get_type() == VALUE_ERROR) return ret;
+    if (algo_name == "read") {
+        return execute_read();
+    } else if (algo_name == "read_line") {
+        return execute_read_line();
+    } else if (algo_name == "open") {
+        return std::make_shared<ErrorValue>(VALUE_ERROR, "Not found!");
+    } else if (algo_name == "clear") {
+        return execute_clear();
+    } else if (algo_name == "quit") {
+        exit(0);
+    } else if (algo_name == "int") {
+        return execute_int(sym.get(arg_names[0])->get_num());
+    } else if (algo_name == "float") {
+        return execute_float(sym.get(arg_names[0])->get_num());
+    } else if (algo_name == "string") {
+        return execute_string(sym.get(arg_names[0])->get_num());
+    } else if (algo_name == "HashTable") {
+        return std::make_shared<HashTableValue>();
     }
-  } else if (obj->get_type() == VALUE_STRING) {
-    if (method_name == "size") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect zero argument for size\n");
-      }
-      return std::make_shared<TypedValue<int64_t>>(
-          VALUE_INT, static_cast<int64_t>(obj->as_string().size()));
+    return ret;
+}
+
+std::shared_ptr<Value> BoundMethodValue::execute(const NodeList& args, SymbolTable* parent) {
+    if (obj->get_type() == VALUE_ARRAY) {
+        ArrayValue* arr_obj = dynamic_cast<ArrayValue*>(obj.get());
+        SymbolTable sym(parent);
+        Interpreter interpreter(sym);
+
+        if (method_name == "push" || method_name == "push_back") {
+            if (args.size() != 1) {
+                return std::make_shared<ErrorValue>(
+                    VALUE_ERROR, "Expect one argument for " + method_name + "\n");
+            }
+            std::shared_ptr<Value> arg = interpreter.visit(args[0]);
+            if (arg->get_type() == VALUE_ERROR) return arg;
+            arr_obj->push_back(arg);
+            return arr_obj->back();
+        } else if (method_name == "pop" || method_name == "pop_back") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(
+                    VALUE_ERROR, "Expect zero argument for " + method_name + "\n");
+            }
+            if (arr_obj->size()->get_num() == "0") {
+                std::cout << "Cannot " << method_name << " from an empty array\n";
+                return std::make_shared<Value>();
+            }
+            return arr_obj->pop_back();
+        } else if (method_name == "resize") {
+            if (args.size() != 1) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect one argument for resize\n");
+            }
+            std::shared_ptr<Value> new_size_val = interpreter.visit(args[0]);
+            if (new_size_val->get_type() == VALUE_ERROR) return new_size_val;
+            if (new_size_val->get_type() != VALUE_INT) {
+                std::cout << "Argument for resize must be an integer\n";
+                return std::make_shared<Value>();
+            }
+            long long new_size;
+            try {
+                new_size = new_size_val->as_int();
+            } catch (const std::out_of_range& oor) {
+                std::cout << "Resize argument out of range\n";
+                return std::make_shared<Value>();
+            }
+            if (new_size < 0) {
+                std::cout << "Resize argument cannot be negative\n";
+                return std::make_shared<Value>();
+            }
+            arr_obj->resize(static_cast<int>(new_size));
+            return obj;
+        } else if (method_name == "insert") {
+            if (args.size() != 2) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect two arguments for insert\n");
+            }
+            std::shared_ptr<Value> index = interpreter.visit(args[0]);
+            if (index->get_type() == VALUE_ERROR) return index;
+            std::shared_ptr<Value> value = interpreter.visit(args[1]);
+            if (value->get_type() == VALUE_ERROR) return value;
+            return arr_obj->insert(index->as_int(), value);
+        } else if (method_name == "remove") {
+            if (args.size() != 1) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect one argument for remove\n");
+            }
+            std::shared_ptr<Value> index = interpreter.visit(args[0]);
+            if (index->get_type() == VALUE_ERROR) return index;
+            return arr_obj->remove(index->as_int());
+        } else if (method_name == "size") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect zero argument for size\n");
+            }
+            return arr_obj->size();
+        } else if (method_name == "back") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect zero arguments for back\n");
+            }
+            if (arr_obj->size()->get_num() == "0") {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Cannot call back on an empty array\n");
+            }
+            return arr_obj->back();
+        }
+    } else if (obj->get_type() == VALUE_STRING) {
+        if (method_name == "size") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect zero argument for size\n");
+            }
+            return std::make_shared<TypedValue<int64_t>>(
+                VALUE_INT, static_cast<int64_t>(obj->as_string().size()));
+        }
+    } else if (obj->get_type() == VALUE_HASH_TABLE) {
+        HashTableValue* table_obj = dynamic_cast<HashTableValue*>(obj.get());
+        SymbolTable sym(parent);
+        Interpreter interpreter(sym);
+
+        if (method_name == "set") {
+            if (args.size() != 2) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect two arguments for set\n");
+            }
+            std::shared_ptr<Value> key = interpreter.visit(args[0]);
+            if (key->get_type() == VALUE_ERROR) return key;
+            std::shared_ptr<Value> value = interpreter.visit(args[1]);
+            if (value->get_type() == VALUE_ERROR) return value;
+            return table_obj->set(key, value);
+        } else if (method_name == "get") {
+            if (args.size() != 1) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect one argument for get\n");
+            }
+            std::shared_ptr<Value> key = interpreter.visit(args[0]);
+            if (key->get_type() == VALUE_ERROR) return key;
+            return table_obj->get(key);
+        } else if (method_name == "contains") {
+            if (args.size() != 1) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect one argument for contains\n");
+            }
+            std::shared_ptr<Value> key = interpreter.visit(args[0]);
+            if (key->get_type() == VALUE_ERROR) return key;
+            return std::make_shared<TypedValue<int64_t>>(VALUE_INT, table_obj->contains(key));
+        } else if (method_name == "remove") {
+            if (args.size() != 1) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect one argument for remove\n");
+            }
+            std::shared_ptr<Value> key = interpreter.visit(args[0]);
+            if (key->get_type() == VALUE_ERROR) return key;
+            return table_obj->remove(key);
+        } else if (method_name == "size") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect zero argument for size\n");
+            }
+            return table_obj->size();
+        } else if (method_name == "is_empty") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect zero argument for is_empty\n");
+            }
+            return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
+                                                         table_obj->size()->as_int() == 0);
+        } else if (method_name == "keys") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR, "Expect zero argument for keys\n");
+            }
+            return table_obj->keys();
+        } else if (method_name == "values") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect zero argument for values\n");
+            }
+            return table_obj->values();
+        } else if (method_name == "clear") {
+            if (!args.empty()) {
+                return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                    "Expect zero argument for clear\n");
+            }
+            table_obj->clear();
+            return obj;
+        }
+    } else if (obj->get_type() == VALUE_INSTANCE) {
+        InstanceValue* inst_obj = dynamic_cast<InstanceValue*>(obj.get());
+        // Find method
+        if (inst_obj->struct_def->methods.count(method_name)) {
+            std::shared_ptr<Value> method = inst_obj->struct_def->methods[method_name];
+            // method is likely AlgoValue.
+            // We need to execute it with 'self' in scope.
+            // We can use the existing AlgoValue::execute, but we need to inject
+            // 'self'. Since AlgoValue::execute creates a new symbol table, we can't
+            // inject it easily from outside *before* it starts unless we modify it or
+            // subclass it. However, we can create a new AlgoValue or wrapper that
+            // injects 'self'.
+
+            // Actually, let's copy the logic of AlgoValue::execute here but add self.
+            AlgoValue* algo_val = dynamic_cast<AlgoValue*>(method.get());
+            if (!algo_val)
+                return std::make_shared<ErrorValue>(VALUE_ERROR, "Method is not an algorithm");
+
+            SymbolTable sym(parent);
+            ScopeCleaner cleaner(sym);
+            Interpreter interpreter(sym);
+
+            // Set self
+            sym.set("self", obj);
+
+            std::shared_ptr<Value> ret{algo_val->set_args(args, sym, interpreter)};
+            if (ret->get_type() == VALUE_ERROR) return ret;
+
+            // Execute body
+            AlgorithmDefNode* algo_node =
+                dynamic_cast<AlgorithmDefNode*>(algo_val->get_node_ptr().get());
+            const NodeList& algo_body = algo_node->get_body();
+
+            std::shared_ptr<Value> res = ret;
+            for (int i = 0; i < algo_body.size(); ++i) {
+                res = interpreter.visit(algo_body[i]);
+                if (res->get_type() == VALUE_ERROR) return res;
+                if (res->get_type() == VALUE_RETURN)
+                    return dynamic_cast<ReturnValue*>(res.get())->get_value();
+            }
+            return res;
+        }
     }
-  } else if (obj->get_type() == VALUE_HASH_TABLE) {
-    HashTableValue *table_obj = dynamic_cast<HashTableValue *>(obj.get());
-    SymbolTable sym(parent);
-    Interpreter interpreter(sym);
+    return std::make_shared<ErrorValue>(
+        VALUE_ERROR, "Unknown member or invalid object for " + method_name + "\n");
+}
 
-    if (method_name == "set") {
-      if (args.size() != 2) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect two arguments for set\n");
-      }
-      std::shared_ptr<Value> key = interpreter.visit(args[0]);
-      if (key->get_type() == VALUE_ERROR)
-        return key;
-      std::shared_ptr<Value> value = interpreter.visit(args[1]);
-      if (value->get_type() == VALUE_ERROR)
-        return value;
-      return table_obj->set(key, value);
-    } else if (method_name == "get") {
-      if (args.size() != 1) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect one argument for get\n");
-      }
-      std::shared_ptr<Value> key = interpreter.visit(args[0]);
-      if (key->get_type() == VALUE_ERROR)
-        return key;
-      return table_obj->get(key);
-    } else if (method_name == "contains") {
-      if (args.size() != 1) {
-        return std::make_shared<ErrorValue>(
-            VALUE_ERROR, "Expect one argument for contains\n");
-      }
-      std::shared_ptr<Value> key = interpreter.visit(args[0]);
-      if (key->get_type() == VALUE_ERROR)
-        return key;
-      return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                   table_obj->contains(key));
-    } else if (method_name == "remove") {
-      if (args.size() != 1) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect one argument for remove\n");
-      }
-      std::shared_ptr<Value> key = interpreter.visit(args[0]);
-      if (key->get_type() == VALUE_ERROR)
-        return key;
-      return table_obj->remove(key);
-    } else if (method_name == "size") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect zero argument for size\n");
-      }
-      return table_obj->size();
-    } else if (method_name == "is_empty") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(
-            VALUE_ERROR, "Expect zero argument for is_empty\n");
-      }
-      return std::make_shared<TypedValue<int64_t>>(
-          VALUE_INT, table_obj->size()->as_int() == 0);
-    } else if (method_name == "keys") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect zero argument for keys\n");
-      }
-      return table_obj->keys();
-    } else if (method_name == "values") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect zero argument for values\n");
-      }
-      return table_obj->values();
-    } else if (method_name == "clear") {
-      if (!args.empty()) {
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Expect zero argument for clear\n");
-      }
-      table_obj->clear();
-      return obj;
-    }
-  } else if (obj->get_type() == VALUE_INSTANCE) {
-    InstanceValue *inst_obj = dynamic_cast<InstanceValue *>(obj.get());
-    // Find method
-    if (inst_obj->struct_def->methods.count(method_name)) {
-      std::shared_ptr<Value> method =
-          inst_obj->struct_def->methods[method_name];
-      // method is likely AlgoValue.
-      // We need to execute it with 'self' in scope.
-      // We can use the existing AlgoValue::execute, but we need to inject
-      // 'self'. Since AlgoValue::execute creates a new symbol table, we can't
-      // inject it easily from outside *before* it starts unless we modify it or
-      // subclass it. However, we can create a new AlgoValue or wrapper that
-      // injects 'self'.
-
-      // Actually, let's copy the logic of AlgoValue::execute here but add self.
-      AlgoValue *algo_val = dynamic_cast<AlgoValue *>(method.get());
-      if (!algo_val)
-        return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                            "Method is not an algorithm");
+std::shared_ptr<Value> BuiltinAlgoValue::execute_print(const std::string& str) {
+    std::cout << str << "\n";
+    return std::make_shared<Value>();
+}
 
-      SymbolTable sym(parent);
-      ScopeCleaner cleaner(sym);
-      Interpreter interpreter(sym);
+std::shared_ptr<Value> BuiltinAlgoValue::execute_read() {
+    std::string ret;
+    std::cin >> ret;
+    std::cin.ignore();
+    return std::make_shared<TypedValue<std::string>>(VALUE_STRING, ret);
+}
 
-      // Set self
-      sym.set("self", obj);
+std::shared_ptr<Value> BuiltinAlgoValue::execute_read_line() {
+    std::string ret;
+    std::getline(std::cin, ret);
+    return std::make_shared<TypedValue<std::string>>(VALUE_STRING, ret);
+}
 
-      std::shared_ptr<Value> ret{algo_val->set_args(args, sym, interpreter)};
-      if (ret->get_type() == VALUE_ERROR)
-        return ret;
+std::shared_ptr<Value> BuiltinAlgoValue::execute_clear() {
+    std::system("clear");
+    return std::make_shared<Value>();
+}
 
-      // Execute body
-      AlgorithmDefNode* algo_node = dynamic_cast<AlgorithmDefNode*>(algo_val->get_node_ptr().get());
-      const NodeList& algo_body = algo_node->get_body();
+std::shared_ptr<Value> BuiltinAlgoValue::execute_int(const std::string& str) {
+    if (str[0] != '-' && !std::isdigit(str[0])) {
+        return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                            "Cannot convert \"" + str + "\" to an int");
+    }
+    for (int i{1}; i < str.size(); ++i)
+        if (!std::isdigit(str[0]))
+            return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                "Cannot convert \"" + str + "\" to an int");
+    return std::make_shared<TypedValue<int64_t>>(VALUE_INT, std::stoll(str));
+}
 
-      std::shared_ptr<Value> res = ret;
-      for (int i = 0; i < algo_body.size(); ++i) {
-        res = interpreter.visit(algo_body[i]);
-        if (res->get_type() == VALUE_ERROR)
-          return res;
-        if (res->get_type() == VALUE_RETURN)
-          return dynamic_cast<ReturnValue*>(res.get())->get_value();
-      }
-      return res;
+std::shared_ptr<Value> BuiltinAlgoValue::execute_float(const std::string& str) {
+    int point{0};
+    if (str[0] != '-' && !std::isdigit(str[0])) {
+        return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                            "Cannot convert \"" + str + "\" to an int");
     }
-  }
-  return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                      "Unknown member or invalid object for " +
-                                          method_name + "\n");
+    for (int i{1}; i < str.size(); ++i) {
+        if (!std::isdigit(str[0]) && (str[0] != '.' || point == 1)) {
+            return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                                "Cannot convert \"" + str + "\" to an int");
+        }
+        if (str[0] == '.') point++;
+    }
+    return std::make_shared<TypedValue<double>>(VALUE_FLOAT, std::stod(str));
 }
 
-std::shared_ptr<Value> BuiltinAlgoValue::execute_print(const std::string &str) {
-  std::cout << str << "\n";
-  return std::make_shared<Value>();
+std::shared_ptr<Value> BuiltinAlgoValue::execute_string(const std::string& str) {
+    return std::make_shared<TypedValue<std::string>>(VALUE_STRING, str);
 }
 
-std::shared_ptr<Value> BuiltinAlgoValue::execute_read() {
-  std::string ret;
-  std::cin >> ret;
-  std::cin.ignore();
-  return std::make_shared<TypedValue<std::string>>(VALUE_STRING, ret);
+std::shared_ptr<Value> operator+(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT, a->as_double() + b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() + b->as_int());
+    else if (a->get_type() == VALUE_STRING && b->get_type() == VALUE_STRING)
+        return std::make_shared<TypedValue<std::string>>(VALUE_STRING,
+                                                         a->as_string() + b->as_string());
+    else
+        return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                            Color(0xFF, 0x39, 0x6E).get() +
+                                                "Runtime ERROR: ADD operation can only apply on "
+                                                "number or two string\n" RESET);
 }
 
-std::shared_ptr<Value> BuiltinAlgoValue::execute_read_line() {
-  std::string ret;
-  std::getline(std::cin, ret);
-  return std::make_shared<TypedValue<std::string>>(VALUE_STRING, ret);
+std::shared_ptr<Value> operator-(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT, a->as_double() - b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() - b->as_int());
+    else
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() +
+                             "Runtime ERROR: SUB operation can only apply on number\n" RESET);
+}
+
+std::shared_ptr<Value> operator*(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT, a->as_double() * b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() * b->as_int());
+    else if (a->get_type() == VALUE_STRING && b->get_type() == VALUE_INT) {
+        std::string ret, str_a{a->as_string()};
+        int64_t times{b->as_int()};
+        for (int i{0}; i < times; ++i) ret += str_a;
+        return std::make_shared<TypedValue<std::string>>(VALUE_STRING, ret);
+    } else
+        return std::make_shared<ErrorValue>(VALUE_ERROR,
+                                            Color(0xFF, 0x39, 0x6E).get() +
+                                                "Runtime ERROR: MUL operation can only apply on "
+                                                "number or string and int\n" RESET);
 }
 
-std::shared_ptr<Value> BuiltinAlgoValue::execute_clear() {
-  std::system("clear");
-  return std::make_shared<Value>();
-}
-
-std::shared_ptr<Value> BuiltinAlgoValue::execute_int(const std::string &str) {
-  if (str[0] != '-' && !std::isdigit(str[0])) {
-    return std::make_shared<ErrorValue>(VALUE_ERROR, "Cannot convert \"" + str +
-                                                         "\" to an int");
-  }
-  for (int i{1}; i < str.size(); ++i)
-    if (!std::isdigit(str[0]))
-      return std::make_shared<ErrorValue>(
-          VALUE_ERROR, "Cannot convert \"" + str + "\" to an int");
-  return std::make_shared<TypedValue<int64_t>>(VALUE_INT, std::stoll(str));
-}
-
-std::shared_ptr<Value> BuiltinAlgoValue::execute_float(const std::string &str) {
-  int point{0};
-  if (str[0] != '-' && !std::isdigit(str[0])) {
-    return std::make_shared<ErrorValue>(VALUE_ERROR, "Cannot convert \"" + str +
-                                                         "\" to an int");
-  }
-  for (int i{1}; i < str.size(); ++i) {
-    if (!std::isdigit(str[0]) && (str[0] != '.' || point == 1)) {
-      return std::make_shared<ErrorValue>(
-          VALUE_ERROR, "Cannot convert \"" + str + "\" to an int");
-    }
-    if (str[0] == '.')
-      point++;
-  }
-  return std::make_shared<TypedValue<double>>(VALUE_FLOAT, std::stod(str));
-}
-
-std::shared_ptr<Value>
-BuiltinAlgoValue::execute_string(const std::string &str) {
-  return std::make_shared<TypedValue<std::string>>(VALUE_STRING, str);
-}
-
-std::shared_ptr<Value> operator+(std::shared_ptr<Value> a,
-                                 std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<double>>(
-        VALUE_FLOAT, a->as_double() + b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() + b->as_int());
-  else if (a->get_type() == VALUE_STRING && b->get_type() == VALUE_STRING)
-    return std::make_shared<TypedValue<std::string>>(
-        VALUE_STRING, a->as_string() + b->as_string());
-  else
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() +
-                         "Runtime ERROR: ADD operation can only apply on "
-                         "number or two string\n" RESET);
-}
-
-std::shared_ptr<Value> operator-(std::shared_ptr<Value> a,
-                                 std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<double>>(
-        VALUE_FLOAT, a->as_double() - b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() - b->as_int());
-  else
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR,
-        Color(0xFF, 0x39, 0x6E).get() +
-            "Runtime ERROR: SUB operation can only apply on number\n" RESET);
-}
-
-std::shared_ptr<Value> operator*(std::shared_ptr<Value> a,
-                                 std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<double>>(
-        VALUE_FLOAT, a->as_double() * b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() * b->as_int());
-  else if (a->get_type() == VALUE_STRING && b->get_type() == VALUE_INT) {
-    std::string ret, str_a{a->as_string()};
-    int64_t times{b->as_int()};
-    for (int i{0}; i < times; ++i)
-      ret += str_a;
-    return std::make_shared<TypedValue<std::string>>(VALUE_STRING, ret);
-  } else
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() +
-                         "Runtime ERROR: MUL operation can only apply on "
-                         "number or string and int\n" RESET);
-}
-
-std::shared_ptr<Value> operator/(std::shared_ptr<Value> a,
-                                 std::shared_ptr<Value> b) {
-  if (b->as_double() == 0.0)
-    return std::make_shared<ErrorValue>(VALUE_ERROR,
-                                        Color(0xFF, 0x39, 0x6E).get() +
-                                            "Runtime ERROR: DIV by 0\n" RESET);
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<double>>(
-        VALUE_FLOAT, a->as_double() / b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() / b->as_int());
-  else
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR,
-        Color(0xFF, 0x39, 0x6E).get() +
-            "Runtime ERROR: DIV operation can only apply on number\n" RESET);
+std::shared_ptr<Value> operator/(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (b->as_double() == 0.0)
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Runtime ERROR: DIV by 0\n" RESET);
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT, a->as_double() / b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() / b->as_int());
+    else
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() +
+                             "Runtime ERROR: DIV operation can only apply on number\n" RESET);
 }
 
-std::shared_ptr<Value> operator%(std::shared_ptr<Value> a,
-                                 std::shared_ptr<Value> b) {
-  if (a->get_type() != VALUE_INT || b->get_type() != VALUE_INT)
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() +
-                         "Cannot apply \"%\" operation on float\n" RESET);
-  return std::make_shared<TypedValue<int64_t>>(
-      VALUE_INT, a->as_int() % b->as_int());
-}
-
-std::shared_ptr<Value> operator==(std::shared_ptr<Value> a,
-                                  std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_INSTANCE || b->get_type() == VALUE_INSTANCE ||
-      a->get_type() == VALUE_ARRAY || b->get_type() == VALUE_ARRAY ||
-      a->get_type() == VALUE_HASH_TABLE || b->get_type() == VALUE_HASH_TABLE ||
-      a->get_type() == VALUE_STRUCT || b->get_type() == VALUE_STRUCT)
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a.get() == b.get());
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_double() == b->as_double());
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 a->as_string() == b->as_string());
-}
-
-std::shared_ptr<Value> operator!=(std::shared_ptr<Value> a,
-                                  std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_INSTANCE || b->get_type() == VALUE_INSTANCE ||
-      a->get_type() == VALUE_ARRAY || b->get_type() == VALUE_ARRAY ||
-      a->get_type() == VALUE_HASH_TABLE || b->get_type() == VALUE_HASH_TABLE ||
-      a->get_type() == VALUE_STRUCT || b->get_type() == VALUE_STRUCT)
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a.get() != b.get());
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_double() != b->as_double());
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 a->as_string() != b->as_string());
-}
-
-std::shared_ptr<Value> operator<(std::shared_ptr<Value> a,
-                                 std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_double() < b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() < b->as_int());
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 a->as_string() < b->as_string());
-}
-
-std::shared_ptr<Value> operator>(std::shared_ptr<Value> a,
-                                 std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_double() > b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() > b->as_int());
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 a->as_string() > b->as_string());
-}
-
-std::shared_ptr<Value> operator<=(std::shared_ptr<Value> a,
-                                  std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_double() <= b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() <= b->as_int());
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 a->as_string() <= b->as_string());
-}
-
-std::shared_ptr<Value> operator>=(std::shared_ptr<Value> a,
-                                  std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_double() >= b->as_double());
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() >= b->as_int());
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 a->as_string() >= b->as_string());
-}
-
-std::shared_ptr<Value> operator&&(std::shared_ptr<Value> a,
-                                  std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT,
-        a->as_double() != 0 && b->as_double() != 0);
-  else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT,
-        a->as_int() != 0 && b->as_int() != 0);
-  else
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() && b->as_int());
-}
-
-std::shared_ptr<Value> operator||(std::shared_ptr<Value> a,
-                                  std::shared_ptr<Value> b) {
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT,
-        a->as_double() != 0 || b->as_double() != 0);
-  else
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT, a->as_int() || b->as_int());
+std::shared_ptr<Value> operator%(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() != VALUE_INT || b->get_type() != VALUE_INT)
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR,
+            Color(0xFF, 0x39, 0x6E).get() + "Cannot apply \"%\" operation on float\n" RESET);
+    return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() % b->as_int());
+}
+
+std::shared_ptr<Value> operator==(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_INSTANCE || b->get_type() == VALUE_INSTANCE ||
+        a->get_type() == VALUE_ARRAY || b->get_type() == VALUE_ARRAY ||
+        a->get_type() == VALUE_HASH_TABLE || b->get_type() == VALUE_HASH_TABLE ||
+        a->get_type() == VALUE_STRUCT || b->get_type() == VALUE_STRUCT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a.get() == b.get());
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_double() == b->as_double());
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_string() == b->as_string());
+}
+
+std::shared_ptr<Value> operator!=(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_INSTANCE || b->get_type() == VALUE_INSTANCE ||
+        a->get_type() == VALUE_ARRAY || b->get_type() == VALUE_ARRAY ||
+        a->get_type() == VALUE_HASH_TABLE || b->get_type() == VALUE_HASH_TABLE ||
+        a->get_type() == VALUE_STRUCT || b->get_type() == VALUE_STRUCT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a.get() != b.get());
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_double() != b->as_double());
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_string() != b->as_string());
+}
+
+std::shared_ptr<Value> operator<(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_double() < b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() < b->as_int());
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_string() < b->as_string());
+}
+
+std::shared_ptr<Value> operator>(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_double() > b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() > b->as_int());
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_string() > b->as_string());
+}
+
+std::shared_ptr<Value> operator<=(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_double() <= b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() <= b->as_int());
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_string() <= b->as_string());
+}
+
+std::shared_ptr<Value> operator>=(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_double() >= b->as_double());
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() >= b->as_int());
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_string() >= b->as_string());
+}
+
+std::shared_ptr<Value> operator&&(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
+                                                     a->as_double() != 0 && b->as_double() != 0);
+    else if (a->get_type() == VALUE_INT && b->get_type() == VALUE_INT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
+                                                     a->as_int() != 0 && b->as_int() != 0);
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() && b->as_int());
+}
+
+std::shared_ptr<Value> operator||(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
+                                                     a->as_double() != 0 || b->as_double() != 0);
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() || b->as_int());
 }
 
 std::shared_ptr<Value> operator-(std::shared_ptr<Value> a) {
-  if (a->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<double>>(VALUE_FLOAT,
-                                                0 - a->as_double());
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 0 - a->as_int());
+    if (a->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT, 0 - a->as_double());
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, 0 - a->as_int());
 }
 
 std::shared_ptr<Value> operator!(std::shared_ptr<Value> a) {
-  if (a->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<double>>(VALUE_FLOAT,
-                                                a->as_double() == 0);
-  else
-    return std::make_shared<TypedValue<int64_t>>(VALUE_INT,
-                                                 a->as_int() == 0);
+    if (a->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT, a->as_double() == 0);
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, a->as_int() == 0);
 }
 
 std::shared_ptr<Value> pow(std::shared_ptr<Value> a, std::shared_ptr<Value> b) {
-  if (a->as_double() == 0.0 && b->as_double() == 0.0)
-    return std::make_shared<ErrorValue>(
-        VALUE_ERROR,
-        Color(0xFF, 0x39, 0x6E).get() + "Runtime ERROR: 0 to the 0\n" RESET);
-  if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
-    return std::make_shared<TypedValue<double>>(
-        VALUE_FLOAT,
-        std::pow(a->as_double(), b->as_double()));
-  else
-    return std::make_shared<TypedValue<int64_t>>(
-        VALUE_INT,
-        std::pow(a->as_int(), b->as_int()));
-}
-
-std::shared_ptr<Value> InstanceValue::get_member(const std::string &name, std::shared_ptr<Value> self) {
-  if (members.count(name)) {
-    return members[name];
-  }
-  // Check for methods in struct definition
-  if (struct_def->methods.count(name)) {
-    if (self.get() == nullptr) {
-         // Fallback if self not provided, but this shouldn't happen for method calls
-         // Create a copy? Or error?
-         // For now, create a copy as before, but warn?
-         return std::make_shared<BoundMethodValue>(
-            std::make_shared<InstanceValue>(*this), name);
-    }
-    return std::make_shared<BoundMethodValue>(self, name);
-  }
-  return std::make_shared<ErrorValue>(VALUE_ERROR, "Member not found: " + name);
-}
-
-void InstanceValue::set_member(const std::string &name,
-                               std::shared_ptr<Value> val) {
-  // If it's declared in struct def members, we can set it.
-  bool found = false;
-  for (const auto &mem : struct_def->members) {
-    if (mem == name) {
-      found = true;
-      break;
-    }
-  }
-  if (found) {
-    members[name] = val;
-  } else {
-    members[name] = val; // Just set it for now.
-  }
-}
-std::shared_ptr<Value> StructValue::execute(const NodeList& args,
-                                            SymbolTable *parent) {
-  // Constructor call
-  std::shared_ptr<InstanceValue> instance =
-      std::make_shared<InstanceValue>(std::make_shared<StructValue>(*this));
-
-  // Initialize members to NONE
-  for (const auto &member : members) {
-    instance->set_member(member, std::make_shared<Value>(VALUE_NONE));
-  }
-
-  // Call constructor if exists
-  if (methods.count("constructor")) {
-    std::shared_ptr<Value> ctor = methods["constructor"];
-    // We need to bind the constructor to the instance
-    std::shared_ptr<BoundMethodValue> bound_ctor =
-        std::make_shared<BoundMethodValue>(instance, "constructor");
-    // But BoundMethodValue execute logic for custom objects is not implemented
-    // in pseudo.cpp yet (only ArrayValue). We need to implement it. Actually,
-    // let's reuse AlgoValue::execute but inject 'self'.
-
-    // Wait, BoundMethodValue holds the object and the method name.
-    // Its execute() needs to look up the method (which we have in 'ctor') and
-    // call it with 'self' = obj.
-
-    // Actually, if we use BoundMethodValue, we need to implement execute for
-    // generic objects. Alternatively, we can manually call ctor->execute(args,
-    // parent) but we need to inject 'self'. AlgoValue::execute creates a new
-    // symbol table. We need to add 'self' to it. But AlgoValue::execute
-    // interface doesn't allow injecting symbols easily before execution.
-    // However, AlgoValue::execute does:
-    // SymbolTable sym(parent);
-    // set_args(args, sym, interpreter);
-    // ...
-
-    // We can manually do what AlgoValue::execute does.
-    // Or we can modify AlgoValue to support binding?
-    // Or implement BoundMethodValue::execute properly.
-  }
-
-  // For now, let's rely on BoundMethodValue which we will implement/update in
-  // pseudo.cpp.
-  if (methods.count("constructor")) {
-    std::shared_ptr<BoundMethodValue> bound_ctor =
-        std::make_shared<BoundMethodValue>(instance, "constructor");
-    std::shared_ptr<Value> ret = bound_ctor->execute(args, parent);
-    if (ret->get_type() == VALUE_ERROR)
-      return ret;
-  }
-
-  return instance;
+    if (a->as_double() == 0.0 && b->as_double() == 0.0)
+        return std::make_shared<ErrorValue>(
+            VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Runtime ERROR: 0 to the 0\n" RESET);
+    if (a->get_type() == VALUE_FLOAT || b->get_type() == VALUE_FLOAT)
+        return std::make_shared<TypedValue<double>>(VALUE_FLOAT,
+                                                    std::pow(a->as_double(), b->as_double()));
+    else
+        return std::make_shared<TypedValue<int64_t>>(VALUE_INT, std::pow(a->as_int(), b->as_int()));
+}
+
+std::shared_ptr<Value> InstanceValue::get_member(const std::string& name,
+                                                 std::shared_ptr<Value> self) {
+    if (members.count(name)) {
+        return members[name];
+    }
+    // Check for methods in struct definition
+    if (struct_def->methods.count(name)) {
+        if (self.get() == nullptr) {
+            // Fallback if self not provided, but this shouldn't happen for method calls
+            // Create a copy? Or error?
+            // For now, create a copy as before, but warn?
+            return std::make_shared<BoundMethodValue>(std::make_shared<InstanceValue>(*this), name);
+        }
+        return std::make_shared<BoundMethodValue>(self, name);
+    }
+    return std::make_shared<ErrorValue>(VALUE_ERROR, "Member not found: " + name);
+}
+
+void InstanceValue::set_member(const std::string& name, std::shared_ptr<Value> val) {
+    // If it's declared in struct def members, we can set it.
+    bool found = false;
+    for (const auto& mem : struct_def->members) {
+        if (mem == name) {
+            found = true;
+            break;
+        }
+    }
+    if (found) {
+        members[name] = val;
+    } else {
+        members[name] = val;  // Just set it for now.
+    }
+}
+std::shared_ptr<Value> StructValue::execute(const NodeList& args, SymbolTable* parent) {
+    // Constructor call
+    std::shared_ptr<InstanceValue> instance =
+        std::make_shared<InstanceValue>(std::make_shared<StructValue>(*this));
+
+    // Initialize members to NONE
+    for (const auto& member : members) {
+        instance->set_member(member, std::make_shared<Value>(VALUE_NONE));
+    }
+
+    // Call constructor if exists
+    if (methods.count("constructor")) {
+        std::shared_ptr<Value> ctor = methods["constructor"];
+        // We need to bind the constructor to the instance
+        std::shared_ptr<BoundMethodValue> bound_ctor =
+            std::make_shared<BoundMethodValue>(instance, "constructor");
+        // But BoundMethodValue execute logic for custom objects is not implemented
+        // in pseudo.cpp yet (only ArrayValue). We need to implement it. Actually,
+        // let's reuse AlgoValue::execute but inject 'self'.
+
+        // Wait, BoundMethodValue holds the object and the method name.
+        // Its execute() needs to look up the method (which we have in 'ctor') and
+        // call it with 'self' = obj.
+
+        // Actually, if we use BoundMethodValue, we need to implement execute for
+        // generic objects. Alternatively, we can manually call ctor->execute(args,
+        // parent) but we need to inject 'self'. AlgoValue::execute creates a new
+        // symbol table. We need to add 'self' to it. But AlgoValue::execute
+        // interface doesn't allow injecting symbols easily before execution.
+        // However, AlgoValue::execute does:
+        // SymbolTable sym(parent);
+        // set_args(args, sym, interpreter);
+        // ...
+
+        // We can manually do what AlgoValue::execute does.
+        // Or we can modify AlgoValue to support binding?
+        // Or implement BoundMethodValue::execute properly.
+    }
+
+    // For now, let's rely on BoundMethodValue which we will implement/update in
+    // pseudo.cpp.
+    if (methods.count("constructor")) {
+        std::shared_ptr<BoundMethodValue> bound_ctor =
+            std::make_shared<BoundMethodValue>(instance, "constructor");
+        std::shared_ptr<Value> ret = bound_ctor->execute(args, parent);
+        if (ret->get_type() == VALUE_ERROR) return ret;
+    }
+
+    return instance;
 }
 
 /// --------------------
@@ -1212,222 +1104,213 @@ std::shared_ptr<Value> StructValue::execute(const NodeList& args,
 
 namespace {
 
-std::string trim(const std::string &str) {
-  size_t begin = 0;
-  while (begin < str.size() &&
-         std::isspace(static_cast<unsigned char>(str[begin]))) {
-    begin++;
-  }
-
-  size_t end = str.size();
-  while (end > begin &&
-         std::isspace(static_cast<unsigned char>(str[end - 1]))) {
-    end--;
-  }
-  return str.substr(begin, end - begin);
-}
-
-bool parse_import_line(const std::string &line, std::string &target) {
-  std::string trimmed = trim(line);
-  const std::string keyword = "import";
-  if (trimmed.rfind(keyword, 0) != 0) {
-    return false;
-  }
-  if (trimmed.size() > keyword.size() &&
-      !std::isspace(static_cast<unsigned char>(trimmed[keyword.size()]))) {
-    return false;
-  }
+std::string trim(const std::string& str) {
+    size_t begin = 0;
+    while (begin < str.size() && std::isspace(static_cast<unsigned char>(str[begin]))) {
+        begin++;
+    }
 
-  target = trim(trimmed.substr(keyword.size()));
-  if (target.empty()) {
-    return false;
-  }
+    size_t end = str.size();
+    while (end > begin && std::isspace(static_cast<unsigned char>(str[end - 1]))) {
+        end--;
+    }
+    return str.substr(begin, end - begin);
+}
+
+bool parse_import_line(const std::string& line, std::string& target) {
+    std::string trimmed = trim(line);
+    const std::string keyword = "import";
+    if (trimmed.rfind(keyword, 0) != 0) {
+        return false;
+    }
+    if (trimmed.size() > keyword.size() &&
+        !std::isspace(static_cast<unsigned char>(trimmed[keyword.size()]))) {
+        return false;
+    }
 
-  if (target.front() == '"' && target.back() == '"' && target.size() >= 2) {
-    target = target.substr(1, target.size() - 2);
-  }
-  return !target.empty();
+    target = trim(trimmed.substr(keyword.size()));
+    if (target.empty()) {
+        return false;
+    }
+
+    if (target.front() == '"' && target.back() == '"' && target.size() >= 2) {
+        target = target.substr(1, target.size() - 2);
+    }
+    return !target.empty();
 }
 
-std::vector<std::filesystem::path>
-candidate_import_paths(const std::string &target,
-                       const std::filesystem::path &base_dir) {
-  namespace fs = std::filesystem;
-  fs::path target_path(target);
-  std::vector<fs::path> candidates;
+std::vector<std::filesystem::path> candidate_import_paths(const std::string& target,
+                                                          const std::filesystem::path& base_dir) {
+    namespace fs = std::filesystem;
+    fs::path target_path(target);
+    std::vector<fs::path> candidates;
+
+    if (target_path.is_absolute()) {
+        candidates.push_back(target_path);
+    } else {
+        if (!target_path.has_extension()) {
+            candidates.push_back(fs::current_path() / "lib" / (target + ".ps"));
+        }
+        candidates.push_back(base_dir / target_path);
+        candidates.push_back(fs::current_path() / target_path);
+    }
 
-  if (target_path.is_absolute()) {
-    candidates.push_back(target_path);
-  } else {
     if (!target_path.has_extension()) {
-      candidates.push_back(fs::current_path() / "lib" / (target + ".ps"));
+        candidates.push_back(base_dir / (target + ".ps"));
+        candidates.push_back(fs::current_path() / (target + ".ps"));
     }
-    candidates.push_back(base_dir / target_path);
-    candidates.push_back(fs::current_path() / target_path);
-  }
 
-  if (!target_path.has_extension()) {
-    candidates.push_back(base_dir / (target + ".ps"));
-    candidates.push_back(fs::current_path() / (target + ".ps"));
-  }
+    return candidates;
+}
 
-  return candidates;
+bool read_file(const std::filesystem::path& path, std::string& text) {
+    std::ifstream input(path);
+    if (!input) {
+        return false;
+    }
+    std::stringstream buffer;
+    buffer << input.rdbuf();
+    text = buffer.str();
+    if (!text.empty() && text.back() != '\n') {
+        text += '\n';
+    }
+    return true;
 }
 
-bool read_file(const std::filesystem::path &path, std::string &text) {
-  std::ifstream input(path);
-  if (!input) {
+bool resolve_import(const std::string& target, const std::filesystem::path& base_dir,
+                    std::filesystem::path& resolved) {
+    namespace fs = std::filesystem;
+    for (const auto& candidate : candidate_import_paths(target, base_dir)) {
+        std::error_code ec;
+        if (fs::exists(candidate, ec) && fs::is_regular_file(candidate, ec)) {
+            resolved = fs::weakly_canonical(candidate, ec);
+            if (ec) {
+                resolved = fs::absolute(candidate, ec);
+            }
+            return true;
+        }
+    }
     return false;
-  }
-  std::stringstream buffer;
-  buffer << input.rdbuf();
-  text = buffer.str();
-  if (!text.empty() && text.back() != '\n') {
-    text += '\n';
-  }
-  return true;
-}
-
-bool resolve_import(const std::string &target,
-                    const std::filesystem::path &base_dir,
-                    std::filesystem::path &resolved) {
-  namespace fs = std::filesystem;
-  for (const auto &candidate : candidate_import_paths(target, base_dir)) {
-    std::error_code ec;
-    if (fs::exists(candidate, ec) && fs::is_regular_file(candidate, ec)) {
-      resolved = fs::weakly_canonical(candidate, ec);
-      if (ec) {
-        resolved = fs::absolute(candidate, ec);
-      }
-      return true;
-    }
-  }
-  return false;
-}
-
-} // namespace
-
-bool expand_imports(const std::string &file_name, const std::string &text,
-                    ImportState &state, std::string &expanded,
-                    std::string &error) {
-  namespace fs = std::filesystem;
-  fs::path current_path(file_name);
-  fs::path base_dir = current_path.has_parent_path()
-                          ? fs::absolute(current_path).parent_path()
-                          : fs::current_path();
-
-  std::stringstream input(text);
-  std::string line;
-  while (std::getline(input, line)) {
-    std::string target;
-    if (!parse_import_line(line, target)) {
-      expanded += line + "\n";
-      continue;
-    }
-
-    fs::path import_path;
-    if (!resolve_import(target, base_dir, import_path)) {
-      error = "Import ERROR: cannot resolve \"" + target + "\" from " +
-              base_dir.string();
-      return false;
-    }
-
-    std::string import_key = import_path.string();
-    if (state.loaded.count(import_key)) {
-      continue;
-    }
-    if (state.loading.count(import_key)) {
-      error = "Import ERROR: circular import involving " + import_key;
-      return false;
-    }
-
-    std::string import_text;
-    if (!read_file(import_path, import_text)) {
-      error = "Import ERROR: cannot read " + import_key;
-      return false;
-    }
-
-    state.loading.insert(import_key);
-    std::string import_expanded;
-    if (!expand_imports(import_key, import_text, state, import_expanded,
-                        error)) {
-      return false;
-    }
-    state.loading.erase(import_key);
-    state.loaded.insert(import_key);
-    expanded += import_expanded;
-    expanded += "\n";
-  }
-  return true;
-}
-
-std::string run(std::string file_name, std::string text,
-                SymbolTable &global_symbol_table) {
-  ImportState import_state;
-  std::string expanded_text;
-  std::string import_error;
-  if (!expand_imports(file_name, text, import_state, expanded_text,
-                      import_error)) {
-    std::cout << import_error << "\n";
-    return "ABORT";
-  }
-
-  Lexer lexer(file_name, expanded_text);
-  TokenList tokens = lexer.make_tokens();
-  if (tokens.empty())
-    return "";
-  if (tokens[0]->get_type() == TOKEN_ERROR) {
-    // std::cout << "Tokens: " << tokens << "\n";
-    // Detailed Lexer Error?
-    // Lexer returns TOKEN_ERROR in list.
-    // But lexer usually returns a list with one error token if it fails?
-    // Or a list where some tokens are errors.
-    // Check lexer.cpp.
-    // Lexer::make_tokens() returns a list. If error, it pushes ErrorToken.
-    // Let's iterate and find errors.
-    for (auto tok : tokens) {
-        if (tok->get_type() == TOKEN_ERROR) {
-             std::cout << "Error: " << tok->get_value() << ", line " << tok->get_pos().line + 1 << ", column: " << tok->get_pos().column << "\n";
-             std::cout << error_marker(expanded_text, tok->get_pos(), tok->get_pos());
-             return "ABORT";
+}
+
+}  // namespace
+
+bool expand_imports(const std::string& file_name, const std::string& text, ImportState& state,
+                    std::string& expanded, std::string& error) {
+    namespace fs = std::filesystem;
+    fs::path current_path(file_name);
+    fs::path base_dir = current_path.has_parent_path() ? fs::absolute(current_path).parent_path()
+                                                       : fs::current_path();
+
+    std::stringstream input(text);
+    std::string line;
+    while (std::getline(input, line)) {
+        std::string target;
+        if (!parse_import_line(line, target)) {
+            expanded += line + "\n";
+            continue;
+        }
+
+        fs::path import_path;
+        if (!resolve_import(target, base_dir, import_path)) {
+            error = "Import ERROR: cannot resolve \"" + target + "\" from " + base_dir.string();
+            return false;
+        }
+
+        std::string import_key = import_path.string();
+        if (state.loaded.count(import_key)) {
+            continue;
+        }
+        if (state.loading.count(import_key)) {
+            error = "Import ERROR: circular import involving " + import_key;
+            return false;
+        }
+
+        std::string import_text;
+        if (!read_file(import_path, import_text)) {
+            error = "Import ERROR: cannot read " + import_key;
+            return false;
+        }
+
+        state.loading.insert(import_key);
+        std::string import_expanded;
+        if (!expand_imports(import_key, import_text, state, import_expanded, error)) {
+            return false;
         }
+        state.loading.erase(import_key);
+        state.loaded.insert(import_key);
+        expanded += import_expanded;
+        expanded += "\n";
     }
-  }
-
-  Parser parser(tokens);
-  NodeList ast = parser.parse();
-
-  for (auto node : ast) {
-    if(node->get_type() == NODE_ERROR) {
-      // std::cout << "Nodes: " << node->get_node() << "\n";
-      std::shared_ptr<Token> err_tok = node->get_tok();
-      if(err_tok) {
-          std::cout << "Error: " << err_tok->get_value() << ", line " << err_tok->get_pos().line + 1 << ", column: " << err_tok->get_pos().column << "\n";
-          std::cout << error_marker(expanded_text, err_tok->get_pos(), err_tok->get_pos());
-      } else {
-          std::cout << "Error: " << node->get_node() << "\n";
-      }
-      return "ABORT";
-    }
-  }
-
-  Interpreter interpreter(global_symbol_table, file_name == "stdin");
-  ArrayValue *ret{new ArrayValue(ValueList(0))};
-  for (auto node : ast) {
-    ret->push_back(interpreter.visit(node));
-    if (ret->back()->get_type() == VALUE_ERROR) {
-      std::cout << ret->back()->get_num() << "\n";
-      return "ABORT";
-    }
-  }
-
-  while (ret->get_type() == VALUE_ARRAY &&
-         ret->back()->get_type() == VALUE_ARRAY) {
-    ret = dynamic_cast<ArrayValue *>(ret->back().get());
-  }
-
-  if (file_name == "stdin" && ret->operator[](0)->get_type() != VALUE_NONE) {
-    std::cout << ret->get_num() << "\n";
-  }
-  return "";
+    return true;
+}
+
+std::string run(std::string file_name, std::string text, SymbolTable& global_symbol_table) {
+    ImportState import_state;
+    std::string expanded_text;
+    std::string import_error;
+    if (!expand_imports(file_name, text, import_state, expanded_text, import_error)) {
+        std::cout << import_error << "\n";
+        return "ABORT";
+    }
+
+    Lexer lexer(file_name, expanded_text);
+    TokenList tokens = lexer.make_tokens();
+    if (tokens.empty()) return "";
+    if (tokens[0]->get_type() == TOKEN_ERROR) {
+        // std::cout << "Tokens: " << tokens << "\n";
+        // Detailed Lexer Error?
+        // Lexer returns TOKEN_ERROR in list.
+        // But lexer usually returns a list with one error token if it fails?
+        // Or a list where some tokens are errors.
+        // Check lexer.cpp.
+        // Lexer::make_tokens() returns a list. If error, it pushes ErrorToken.
+        // Let's iterate and find errors.
+        for (auto tok : tokens) {
+            if (tok->get_type() == TOKEN_ERROR) {
+                std::cout << "Error: " << tok->get_value() << ", line " << tok->get_pos().line + 1
+                          << ", column: " << tok->get_pos().column << "\n";
+                std::cout << error_marker(expanded_text, tok->get_pos(), tok->get_pos());
+                return "ABORT";
+            }
+        }
+    }
+
+    Parser parser(tokens);
+    NodeList ast = parser.parse();
+
+    for (auto node : ast) {
+        if (node->get_type() == NODE_ERROR) {
+            // std::cout << "Nodes: " << node->get_node() << "\n";
+            std::shared_ptr<Token> err_tok = node->get_tok();
+            if (err_tok) {
+                std::cout << "Error: " << err_tok->get_value() << ", line "
+                          << err_tok->get_pos().line + 1
+                          << ", column: " << err_tok->get_pos().column << "\n";
+                std::cout << error_marker(expanded_text, err_tok->get_pos(), err_tok->get_pos());
+            } else {
+                std::cout << "Error: " << node->get_node() << "\n";
+            }
+            return "ABORT";
+        }
+    }
+
+    Interpreter interpreter(global_symbol_table, file_name == "stdin");
+    ArrayValue* ret{new ArrayValue(ValueList(0))};
+    for (auto node : ast) {
+        ret->push_back(interpreter.visit(node));
+        if (ret->back()->get_type() == VALUE_ERROR) {
+            std::cout << ret->back()->get_num() << "\n";
+            return "ABORT";
+        }
+    }
+
+    while (ret->get_type() == VALUE_ARRAY && ret->back()->get_type() == VALUE_ARRAY) {
+        ret = dynamic_cast<ArrayValue*>(ret->back().get());
+    }
+
+    if (file_name == "stdin" && ret->operator[](0)->get_type() != VALUE_NONE) {
+        std::cout << ret->get_num() << "\n";
+    }
+    return "";
 }
diff --git a/src/value.h b/src/value.h
index feb7d6b..fab534a 100644
--- a/src/value.h
+++ b/src/value.h
@@ -5,12 +5,13 @@
 #ifndef VALUE_H
 #define VALUE_H
 
-#include <string>
-#include <vector>
-#include <memory>
+#include <cstdint>
 #include <map>
+#include <memory>
+#include <string>
 #include <unordered_map>
-#include <cstdint>
+#include <vector>
+
 #include "node.h"
 
 const std::string VALUE_NONE{"NONE"};
@@ -27,41 +28,37 @@ const std::string VALUE_RETURN{"Return"};
 const std::string VALUE_BREAK{"Break"};
 const std::string VALUE_CONTINUE{"Continue"};
 
-const std::map<char, char> REVERSE_ESCAPE_CHAR {
-    {'\n', 'n'}, {'\r', 'r'},
-    {'\b', 'b'}, {'\"', '\"'},
-    {'\'', '\''}, {'\\', '\\'},
-    {'\t', 't'}
-};
+const std::map<char, char> REVERSE_ESCAPE_CHAR{
+    {'\n', 'n'}, {'\r', 'r'}, {'\b', 'b'}, {'\"', '\"'}, {'\'', '\''}, {'\\', '\\'}, {'\t', 't'}};
 
 class SymbolTable;
 class Interpreter;
-class Value: public std::enable_shared_from_this<Value> {
-public:
-    Value(const std::string& _type = VALUE_NONE)
-        : type(_type) {}
-    virtual std::string get_num() { return type;}
-    virtual std::string repr() { return type;}
-    virtual std::string get_type(){ return type;}
+class Value : public std::enable_shared_from_this<Value> {
+   public:
+    Value(const std::string& _type = VALUE_NONE) : type(_type) {}
+    virtual std::string get_num() { return type; }
+    virtual std::string repr() { return type; }
+    virtual std::string get_type() { return type; }
     virtual int64_t as_int();
     virtual double as_double();
     virtual std::string as_string();
     virtual bool append_string(const std::string&) { return false; }
-    virtual std::shared_ptr<Value> execute(const NodeList& args = {}, SymbolTable *parent = nullptr)
-        { return std::make_shared<Value>();};
-    friend std::ostream& operator<<(std::ostream &out, Value &token);
-    
-protected:
+    virtual std::shared_ptr<Value> execute(const NodeList& args = {},
+                                           SymbolTable* parent = nullptr) {
+        return std::make_shared<Value>();
+    };
+    friend std::ostream& operator<<(std::ostream& out, Value& token);
+
+   protected:
     std::string type;
 };
 
 using ValueList = std::vector<std::shared_ptr<Value>>;
 
-template<typename T>
-class TypedValue: public Value {
-public:
-    TypedValue(const std::string& _type, const T &_value) 
-        : Value(_type), value(_value) {}
+template <typename T>
+class TypedValue : public Value {
+   public:
+    TypedValue(const std::string& _type, const T& _value) : Value(_type), value(_value) {}
     std::string get_num() override;
     std::string repr() override;
     int64_t as_int() override;
@@ -69,50 +66,53 @@ class TypedValue: public Value {
     std::string as_string() override;
     bool append_string(const std::string&) override;
 
-protected:
+   protected:
     T value;
 };
 
 using ErrorValue = TypedValue<std::string>;
 
-class BaseAlgoValue: public Value {
-public:
-    BaseAlgoValue(const std::string &_algo_name, std::shared_ptr<Node> _value) 
+class BaseAlgoValue : public Value {
+   public:
+    BaseAlgoValue(const std::string& _algo_name, std::shared_ptr<Node> _value)
         : Value(VALUE_ALGO), value(_value), algo_name(_algo_name) {
         for (const auto& tok : value->get_toks()) {
             arg_names.push_back(tok->get_value());
         }
     }
-    std::string get_num() override { return algo_name;}
+    std::string get_num() override { return algo_name; }
     virtual std::shared_ptr<Value> set_args(const NodeList&, SymbolTable&, Interpreter&);
-    std::string repr() override { return get_num();}
+    std::string repr() override { return get_num(); }
 
-protected:
+   protected:
     std::string algo_name;
     std::shared_ptr<Node> value;
     std::vector<std::string> arg_names;
 };
 
-class AlgoValue: public BaseAlgoValue {
-public:
-    AlgoValue(const std::string &_algo_name, std::shared_ptr<Node> _value) 
+class AlgoValue : public BaseAlgoValue {
+   public:
+    AlgoValue(const std::string& _algo_name, std::shared_ptr<Node> _value)
         : BaseAlgoValue(_algo_name, _value) {}
-    std::string get_num() override { return algo_name;}
-    std::string repr() override { return get_num();}
-    std::shared_ptr<Value> execute(const NodeList& args = {}, SymbolTable *parent = nullptr) override;
+    std::string get_num() override { return algo_name; }
+    std::string repr() override { return get_num(); }
+    std::shared_ptr<Value> execute(const NodeList& args = {},
+                                   SymbolTable* parent = nullptr) override;
     friend class BoundMethodValue;
     // Expose value for friends/derived or public use if needed for method binding
     std::shared_ptr<Node> get_node_ptr() { return value; }
     const std::vector<std::string>& get_arg_names() const { return arg_names; }
-protected:
+
+   protected:
 };
 
-class BuiltinAlgoValue: public BaseAlgoValue {
-public:
-    BuiltinAlgoValue(const std::string &_algo_name, std::shared_ptr<Node> _value) 
+class BuiltinAlgoValue : public BaseAlgoValue {
+   public:
+    BuiltinAlgoValue(const std::string& _algo_name, std::shared_ptr<Node> _value)
         : BaseAlgoValue(_algo_name, _value) {}
-    std::string get_num() override { return algo_name;}
-    std::shared_ptr<Value> execute(const NodeList& args = {}, SymbolTable *parent = nullptr) override;
+    std::string get_num() override { return algo_name; }
+    std::shared_ptr<Value> execute(const NodeList& args = {},
+                                   SymbolTable* parent = nullptr) override;
     std::shared_ptr<Value> execute_print(const std::string&);
     std::shared_ptr<Value> execute_read();
     std::shared_ptr<Value> execute_read_line();
@@ -120,36 +120,40 @@ class BuiltinAlgoValue: public BaseAlgoValue {
     std::shared_ptr<Value> execute_int(const std::string&);
     std::shared_ptr<Value> execute_float(const std::string&);
     std::shared_ptr<Value> execute_string(const std::string&);
-    std::string repr() override { return get_num();}
-protected:
+    std::string repr() override { return get_num(); }
+
+   protected:
 };
 
 class BoundMethodValue : public Value {
-public:
+   public:
     BoundMethodValue(std::shared_ptr<Value> _obj, std::string _method_name)
         : Value(VALUE_ALGO), obj(_obj), method_name(_method_name) {}
-    std::shared_ptr<Value> execute(const NodeList& args = {}, SymbolTable *parent = nullptr) override;
+    std::shared_ptr<Value> execute(const NodeList& args = {},
+                                   SymbolTable* parent = nullptr) override;
     std::string get_num() override { return method_name; }
     std::string repr() override { return "<Bound Method " + method_name + ">"; }
-protected:
+
+   protected:
     std::shared_ptr<Value> obj;
     std::string method_name;
 };
 
-class ArrayValue: public Value {
-public:
-    ArrayValue(ValueList _value) 
-        : Value(VALUE_ARRAY), value(_value) {}
+class ArrayValue : public Value {
+   public:
+    ArrayValue(ValueList _value) : Value(VALUE_ARRAY), value(_value) {}
     std::string get_num() override;
     std::shared_ptr<Value>& operator[](int p);
     void push_back(std::shared_ptr<Value>);
     std::shared_ptr<Value> insert(int p, std::shared_ptr<Value>);
     std::shared_ptr<Value> remove(int p);
     std::shared_ptr<Value> pop_back();
-    bool empty() const { return value.empty();}
-    std::shared_ptr<Value>& size() { return sz = std::make_shared<TypedValue<int64_t>>(VALUE_INT, value.size());};
-    std::shared_ptr<Value>& back() { return value.back();};
-    std::string repr() override { return get_num();}
+    bool empty() const { return value.empty(); }
+    std::shared_ptr<Value>& size() {
+        return sz = std::make_shared<TypedValue<int64_t>>(VALUE_INT, value.size());
+    };
+    std::shared_ptr<Value>& back() { return value.back(); };
+    std::string repr() override { return get_num(); }
 
     void resize(int new_size) {
         if (new_size < 0) {
@@ -161,20 +165,20 @@ class ArrayValue: public Value {
             size_t old_size = value.size();
             value.resize(new_size);
             for (size_t i = old_size; i < static_cast<size_t>(new_size); ++i) {
-                value[i] = std::make_shared<Value>(); // Fill with default Value
+                value[i] = std::make_shared<Value>();  // Fill with default Value
             }
         }
     }
 
     std::shared_ptr<Value> sz, error;
-protected:
+
+   protected:
     ValueList value;
 };
 
-class HashTableValue: public Value {
-public:
-    HashTableValue()
-        : Value(VALUE_HASH_TABLE) {}
+class HashTableValue : public Value {
+   public:
+    HashTableValue() : Value(VALUE_HASH_TABLE) {}
     std::string get_num() override;
     std::string repr() override { return get_num(); }
     std::shared_ptr<Value> get(std::shared_ptr<Value> key);
@@ -186,7 +190,7 @@ class HashTableValue: public Value {
     std::shared_ptr<Value> values() const;
     void clear();
 
-protected:
+   protected:
     struct Entry {
         std::shared_ptr<Value> key;
         std::shared_ptr<Value> value;
@@ -219,8 +223,9 @@ std::shared_ptr<Value> operator-(std::shared_ptr<Value>);
 std::shared_ptr<Value> operator!(std::shared_ptr<Value>);
 
 class StructValue : public Value {
-public:
-    StructValue(const std::string& _name, const std::vector<std::string>& _members, const std::map<std::string, std::shared_ptr<Value>>& _methods)
+   public:
+    StructValue(const std::string& _name, const std::vector<std::string>& _members,
+                const std::map<std::string, std::shared_ptr<Value>>& _methods)
         : Value(VALUE_STRUCT), name(_name), members(_members), methods(_methods) {}
 
     std::string get_num() override { return name; }
@@ -229,18 +234,20 @@ class StructValue : public Value {
     std::vector<std::string> members;
     std::map<std::string, std::shared_ptr<Value>> methods;
     std::string name;
-    std::shared_ptr<Value> execute(const NodeList& args = {}, SymbolTable *parent = nullptr) override;
+    std::shared_ptr<Value> execute(const NodeList& args = {},
+                                   SymbolTable* parent = nullptr) override;
 };
 
 class InstanceValue : public Value {
-public:
+   public:
     InstanceValue(std::shared_ptr<StructValue> _struct_def)
         : Value(VALUE_INSTANCE), struct_def(_struct_def) {}
 
     std::string get_num() override { return struct_def->name + " Instance"; }
     std::string repr() override { return "<Instance of " + struct_def->name + ">"; }
 
-    std::shared_ptr<Value> get_member(const std::string& name, std::shared_ptr<Value> self = nullptr);
+    std::shared_ptr<Value> get_member(const std::string& name,
+                                      std::shared_ptr<Value> self = nullptr);
     void set_member(const std::string& name, std::shared_ptr<Value> val);
 
     std::shared_ptr<StructValue> struct_def;
@@ -248,32 +255,31 @@ class InstanceValue : public Value {
 };
 
 class ReturnValue : public Value {
-public:
-    ReturnValue(std::shared_ptr<Value> _value)
-        : Value(VALUE_RETURN), value(_value) {}
+   public:
+    ReturnValue(std::shared_ptr<Value> _value) : Value(VALUE_RETURN), value(_value) {}
     std::string get_num() override { return value->get_num(); }
     std::string repr() override { return value->repr(); }
     std::shared_ptr<Value> get_value() { return value; }
-protected:
+
+   protected:
     std::shared_ptr<Value> value;
 };
 
 class ControlValue : public Value {
-public:
-    ControlValue(const std::string& _type)
-        : Value(_type) {}
+   public:
+    ControlValue(const std::string& _type) : Value(_type) {}
 };
 
 // Wraps an already-evaluated value as an AST node so compiled code can reuse
 // interpreter execution paths that expect argument nodes (builtins, methods).
-class PrecomputedNode: public Node {
-public:
-    explicit PrecomputedNode(std::shared_ptr<Value> _value)
-        : value(_value) {}
-    std::string get_node() override { return "PRECOMPUTED";}
-    std::string get_type() override { return NODE_PRECOMPUTED;}
-    std::shared_ptr<Value> get_value() { return value;}
-protected:
+class PrecomputedNode : public Node {
+   public:
+    explicit PrecomputedNode(std::shared_ptr<Value> _value) : value(_value) {}
+    std::string get_node() override { return "PRECOMPUTED"; }
+    std::string get_type() override { return NODE_PRECOMPUTED; }
+    std::shared_ptr<Value> get_value() { return value; }
+
+   protected:
     std::shared_ptr<Value> value;
 };
 

From 35ea4736b3243a66120d9626eb0fc0274cb53ec5 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 20:45:25 +0800
Subject: [PATCH 09/12] style: satisfy clang-tidy include-cleaner and naming
 rules in touched files

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 pseudoc             | Bin 845032 -> 845032 bytes
 src/compiler.cpp    |  15 +++++++++++----
 src/interpreter.cpp |  17 +++++++++++++----
 src/pseudo.cpp      |  21 ++++++++++++++++-----
 src/pseudoc.cpp     |   7 ++++++-
 src/runtime.cpp     |   4 +++-
 6 files changed, 49 insertions(+), 15 deletions(-)

diff --git a/pseudoc b/pseudoc
index e722f99b4b067f7e325d5ef9e44cf96fce1dac27..333112da4675b96d2bd501adfbc4dce4ca2f2bb9 100755
GIT binary patch
delta 27845
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

delta 27837
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%0DJa2-`(+~Knlxy@W}J%c*ovJv6X#(k_TikE
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
bnW}Bio3C0M?VedD=bILl&WE+X^eX=kA4;EO

diff --git a/src/compiler.cpp b/src/compiler.cpp
index e45b0aa..671db6b 100644
--- a/src/compiler.cpp
+++ b/src/compiler.cpp
@@ -9,15 +9,22 @@
 
 #include "compiler.h"
 
+#include <llvm/IR/BasicBlock.h>
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/DerivedTypes.h>
 #include <llvm/IR/Function.h>
+#include <llvm/IR/GlobalValue.h>
 #include <llvm/IR/GlobalVariable.h>
 #include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Instructions.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Module.h>
+#include <llvm/Support/Casting.h>
 
+#include <cstddef>
+#include <cstdint>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -133,7 +140,7 @@ class CodeGen {
     // runtime Value) or nullptr when the node terminated the current block
     // (break/continue/return) or reported a compile error.
     llvm::Value* gen(const std::shared_ptr<Node>& node) {
-        const std::string type = node->get_type();
+        std::string type = node->get_type();
         if (type == NODE_VALUE) return gen_literal(node);
         if (type == NODE_VARACCESS) return gen_var_access(node);
         if (type == NODE_VARASSIGN) return gen_var_assign(node);
@@ -419,7 +426,7 @@ class CodeGen {
         if (end == nullptr) return nullptr;
         builder.CreateCall(get_rt("rt_for_step_check", builder.getVoidTy(), {ptr_ty}), {step});
 
-        const std::string var_name = child[0]->get_name();
+        std::string var_name = child[0]->get_name();
         llvm::AllocaInst* slot = entry_alloca(ptr_ty);
         builder.CreateStore(init, slot);
 
@@ -518,7 +525,7 @@ class CodeGen {
     /// ---- functions and calls ----
 
     llvm::Value* gen_algo_def(const std::shared_ptr<Node>& node) {
-        const std::string name = node->get_name();
+        std::string name = node->get_name();
         if (name.find("::") != std::string::npos) {
             error("compile error: Struct is not supported by the compiler yet", node);
             return nullptr;
@@ -560,7 +567,7 @@ class CodeGen {
         auto* names_global =
             new llvm::GlobalVariable(module, names_ty, true, llvm::GlobalValue::PrivateLinkage,
                                      llvm::ConstantArray::get(names_ty, name_ptrs), "args");
-        const bool memoizable = is_memoizable_numeric_algo(node, name, arg_names);
+        bool memoizable = is_memoizable_numeric_algo(node, name, arg_names);
         return builder.CreateCall(
             get_rt("rt_define_algo", ptr_ty, {ptr_ty, ptr_ty, ptr_ty, i64_ty, i64_ty}),
             {cstring(name), fn, names_global,
diff --git a/src/interpreter.cpp b/src/interpreter.cpp
index 0d17bfb..26a00e0 100644
--- a/src/interpreter.cpp
+++ b/src/interpreter.cpp
@@ -4,13 +4,22 @@
 
 #include "interpreter.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <iostream>
+#include <map>
 #include <memory>
+#include <optional>
 #include <stdexcept>
+#include <string>
 #include <unordered_map>
+#include <utility>
+#include <vector>
 
+#include "jit.h"
 #include "node.h"
+#include "token.h"
 #include "value.h"
 
 namespace {
@@ -24,7 +33,7 @@ bool is_jit_root(const std::shared_ptr<Node>& node) {
 
 bool has_assignment_node(const std::shared_ptr<Node>& node) {
     if (!node) return false;
-    const std::string type = node->get_type();
+    std::string type = node->get_type();
     if (type == NODE_VARASSIGN || type == NODE_ARRASSIGN) {
         return true;
     }
@@ -687,8 +696,8 @@ std::optional<std::shared_ptr<Value>> Interpreter::try_visit_array_method_call(
     }
 
     NodeList member_child = call_node->get_child();
-    const std::string method_name = member_child[1]->get_name();
-    const bool supported_method =
+    std::string method_name = member_child[1]->get_name();
+    bool supported_method =
         method_name == "push" || method_name == "push_back" || method_name == "pop" ||
         method_name == "pop_back" || method_name == "resize" || method_name == "size" ||
         method_name == "back" || method_name == "insert" || method_name == "remove";
@@ -824,7 +833,7 @@ std::shared_ptr<Value> Interpreter::bin_op(std::shared_ptr<Value> a, std::shared
     else if (op->get_type() == TOKEN_MOD)
         return a % b;
     else if (op->get_type() == TOKEN_POW)
-        return pow(a, b);
+        return pow(a, b);  // NOLINT(misc-include-cleaner): value.h overload
     else if (op->get_type() == TOKEN_EQUAL)
         return a == b;
     else if (op->get_type() == TOKEN_NEQ)
diff --git a/src/pseudo.cpp b/src/pseudo.cpp
index 5cac55c..e2d69da 100644
--- a/src/pseudo.cpp
+++ b/src/pseudo.cpp
@@ -2,16 +2,23 @@
 
 #include <cctype>
 #include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
+#include <memory>
 #include <optional>
 #include <set>
 #include <sstream>
+#include <stdexcept>
 #include <string>
+#include <system_error>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 #include "analysis.h"
@@ -19,7 +26,11 @@
 #include "error.h"
 #include "imports.h"
 #include "interpreter.h"
+#include "jit.h"
+#include "lexer.h"
 #include "node.h"
+#include "parser.h"
+#include "token.h"
 #include "value.h"
 
 /// --------------------
@@ -309,9 +320,9 @@ bool is_pure_numeric_node(const std::shared_ptr<Node>& node, const std::string&
                           const std::unordered_set<std::string>& arg_names) {
     if (!node) return false;
 
-    const std::string type = node->get_type();
+    std::string type = node->get_type();
     if (type == NODE_VALUE) {
-        const std::string token_type = node->get_tok()->get_type();
+        std::string token_type = node->get_tok()->get_type();
         return token_type == TOKEN_INT || token_type == TOKEN_FLOAT;
     }
     if (type == NODE_VARACCESS) {
@@ -448,7 +459,7 @@ std::shared_ptr<Value> AlgoValue::execute(const NodeList& args, SymbolTable* par
     SymbolTable sym(parent);
     ScopeCleaner cleaner(sym);
     Interpreter interpreter(sym);
-    const std::size_t node_id = value->get_id();
+    std::size_t node_id = value->get_id();
     auto memoizable_found = memoizable_by_node.find(node_id);
     if (memoizable_found == memoizable_by_node.end()) {
         memoizable_found =
@@ -474,7 +485,7 @@ std::shared_ptr<Value> AlgoValue::execute(const NodeList& args, SymbolTable* par
             evaluated_args.push_back(arg);
         }
 
-        const std::string cache_key = numeric_cache_key(evaluated_args);
+        std::string cache_key = numeric_cache_key(evaluated_args);
         if (!cache_key.empty()) {
             auto& cache = memoized_results[node_id];
             auto cached = cache.find(cache_key);
@@ -1119,7 +1130,7 @@ std::string trim(const std::string& str) {
 
 bool parse_import_line(const std::string& line, std::string& target) {
     std::string trimmed = trim(line);
-    const std::string keyword = "import";
+    std::string keyword = "import";
     if (trimmed.rfind(keyword, 0) != 0) {
         return false;
     }
diff --git a/src/pseudoc.cpp b/src/pseudoc.cpp
index 9c1bd2c..48ca45d 100644
--- a/src/pseudoc.cpp
+++ b/src/pseudoc.cpp
@@ -5,12 +5,16 @@
 /// Compiles a .ps source file to a native executable:
 ///   pseudoc <file.ps> [-o <out>] [--emit-llvm] [--runtime-lib <path>]
 
+#include <llvm/Analysis/CGSCCPassManager.h>
+#include <llvm/Analysis/LoopAnalysisManager.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/LegacyPassManager.h>
 #include <llvm/IR/Module.h>
+#include <llvm/IR/PassManager.h>
 #include <llvm/IR/Verifier.h>
 #include <llvm/MC/TargetRegistry.h>
 #include <llvm/Passes/PassBuilder.h>
+#include <llvm/Support/CodeGen.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/TargetSelect.h>
 #include <llvm/Support/raw_ostream.h>
@@ -23,8 +27,9 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <sstream>
+#include <memory>
 #include <string>
+#include <system_error>
 #include <vector>
 
 #include "compiler.h"
diff --git a/src/runtime.cpp b/src/runtime.cpp
index fc67757..e54b83e 100644
--- a/src/runtime.cpp
+++ b/src/runtime.cpp
@@ -4,11 +4,13 @@
 
 #include "runtime.h"
 
+#include <cstdint>
 #include <cstdlib>
 #include <iostream>
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 #include "color.h"
@@ -178,7 +180,7 @@ Value* rt_bin_op(int64_t op, Value* a, Value* b) {
         case RT_OP_MOD:
             return track(lhs % rhs);
         case RT_OP_POW:
-            return track(pow(lhs, rhs));
+            return track(pow(lhs, rhs));  // NOLINT(misc-include-cleaner): value.h overload
         case RT_OP_EQUAL:
             return track(lhs == rhs);
         case RT_OP_NEQ:

From 0db39d56e95e847d0b330f488af5913306560117 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 22:41:18 +0800
Subject: [PATCH 10/12] feat: compile structs in LLVM backend

---
 README.md                                     |   2 -
 .../specs/2026-06-10-llvm-compiler-design.md  |  16 +--
 src/compiler.cpp                              | 125 ++++++++++++++----
 src/pseudo.cpp                                |  21 ++-
 src/runtime.cpp                               |  82 ++++++++++--
 src/runtime.h                                 |   5 +
 test/compiler_tests.sh                        |  13 +-
 7 files changed, 190 insertions(+), 74 deletions(-)

diff --git a/README.md b/README.md
index f314a24..2b416a9 100644
--- a/README.md
+++ b/README.md
@@ -31,8 +31,6 @@ applies. Compiled output is verified against the interpreter by
 
 Current limitations:
 
-- `Struct` definitions are not supported yet (clear compile-time error);
-  `import` of struct-based modules such as `dsa` therefore also fails.
 - A loop used as a function's implicit return value evaluates to `NONE`
   instead of the interpreter's collected per-iteration array.
 
diff --git a/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md b/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
index bafbede..0a1f14b 100644
--- a/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
+++ b/docs/superpowers/specs/2026-06-10-llvm-compiler-design.md
@@ -86,6 +86,12 @@ its `shared_ptr` in the current frame. Frames are pushed/popped:
   `rt_index_assign` mirroring `visit_member_access`, `visit_array_access`,
   `visit_array_assign` (string 1-indexing, hash get/set, array element
   assignment).
+- Struct definitions: in-struct methods compile to private algorithm functions
+  and runtime `CompiledAlgoValue`s, then `rt_define_struct` registers a
+  `StructValue` with member and method maps. Later `Algorithm Struct::method`
+  definitions compile as global algorithms and call `rt_struct_add_method` at
+  the definition site, matching the interpreter's attachment timing. Bound
+  instance method calls execute with a parent scope containing `self`.
 - Array literals: `rt_array_new` + `rt_array_push`.
 - Errors: any `rt_*` function that produces or receives a `VALUE_ERROR` prints
   `err->get_num()` (same text the interpreter prints at top level) and exits
@@ -104,14 +110,6 @@ its `shared_ptr` in the current frame. Frames are pushed/popped:
   by-argument memoization via `rt_define_algo(..., memoizable)`, using the
   shared `is_memoizable_numeric_algo` analysis (src/analysis.h).
 
-### Unsupported in v1 (clean compile-time error)
-
-- `Struct` definitions / instances (`NODE_STRUCTDEF`, member assignment on
-  instances). The compiler reports "compile error: Struct is not supported by
-  the compiler yet" with the source location. `import` works (textual
-  expansion before parsing), but importing a file that defines structs (e.g.
-  `dsa`) hits the same error.
-
 ### Intrusive changes to existing code (kept minimal)
 
 1. `Value` inherits `std::enable_shared_from_this<Value>` (value.h).
@@ -157,7 +155,7 @@ with `pseudoc` and asserts its stdout equals `./pseudo file.ps` stdout.
 Coverage: arithmetic/comparison/logic on ints/floats/strings, arrays +
 methods, hash tables, string indexing, if/for/while/repeat with
 break/continue, recursion (fib), nested functions, argument-count errors,
-runtime errors (index out of range), and the struct compile-error path.
+runtime errors (index out of range), and struct construction/method calls.
 Existing `make test` (gtest) must keep passing.
 
 ## Performance expectation
diff --git a/src/compiler.cpp b/src/compiler.cpp
index 671db6b..ada0a8c 100644
--- a/src/compiler.cpp
+++ b/src/compiler.cpp
@@ -111,6 +111,37 @@ class CodeGen {
         return tmp.CreateAlloca(type);
     }
 
+    llvm::Value* string_array(const std::vector<std::string>& strings,
+                              const std::string& global_name) {
+        if (strings.empty()) {
+            return llvm::ConstantPointerNull::get(ptr_ty);
+        }
+
+        llvm::ArrayType* strings_ty = llvm::ArrayType::get(ptr_ty, strings.size());
+        std::vector<llvm::Constant*> string_ptrs;
+        string_ptrs.reserve(strings.size());
+        for (const auto& value : strings) {
+            string_ptrs.push_back(llvm::cast<llvm::Constant>(cstring(value)));
+        }
+        return new llvm::GlobalVariable(module, strings_ty, true, llvm::GlobalValue::PrivateLinkage,
+                                        llvm::ConstantArray::get(strings_ty, string_ptrs),
+                                        global_name);
+    }
+
+    llvm::Value* value_array(const std::vector<llvm::Value*>& values) {
+        if (values.empty()) {
+            return llvm::ConstantPointerNull::get(ptr_ty);
+        }
+
+        llvm::ArrayType* values_ty = llvm::ArrayType::get(ptr_ty, values.size());
+        llvm::AllocaInst* slots = entry_alloca(values_ty);
+        for (size_t i = 0; i < values.size(); ++i) {
+            builder.CreateStore(values[i],
+                                builder.CreateConstInBoundsGEP2_64(values_ty, slots, 0, i));
+        }
+        return slots;
+    }
+
     void error(const std::string& message, const std::shared_ptr<Node>& node) {
         std::string suffix;
         std::shared_ptr<Token> tok = node ? node->get_tok() : nullptr;
@@ -159,10 +190,7 @@ class CodeGen {
         if (type == NODE_RETURN) return gen_return(node);
         if (type == NODE_BREAK) return gen_loop_jump(node, true);
         if (type == NODE_CONTINUE) return gen_loop_jump(node, false);
-        if (type == NODE_STRUCTDEF) {
-            error("compile error: Struct is not supported by the compiler yet", node);
-            return nullptr;
-        }
+        if (type == NODE_STRUCTDEF) return gen_struct_def(node);
         error("compile error: unsupported statement " + type, node);
         return nullptr;
     }
@@ -524,19 +552,8 @@ class CodeGen {
 
     /// ---- functions and calls ----
 
-    llvm::Value* gen_algo_def(const std::shared_ptr<Node>& node) {
-        std::string name = node->get_name();
-        if (name.find("::") != std::string::npos) {
-            error("compile error: Struct is not supported by the compiler yet", node);
-            return nullptr;
-        }
-
+    llvm::Function* emit_algo_function(const std::shared_ptr<Node>& node, const std::string& name) {
         AlgorithmDefNode* def = dynamic_cast<AlgorithmDefNode*>(node.get());
-        std::vector<std::string> arg_names;
-        for (const auto& tok : node->get_toks()) {
-            arg_names.push_back(tok->get_value());
-        }
-
         llvm::Function* fn = llvm::Function::Create(
             llvm::FunctionType::get(ptr_ty, false), llvm::Function::PrivateLinkage,
             "ps.algo." + std::to_string(algo_counter++) + "." + name, module);
@@ -557,22 +574,46 @@ class CodeGen {
         if (!errors.empty()) {
             return nullptr;
         }
+        return fn;
+    }
 
-        // Registration happens at the definition site, like visit_algo_def.
-        llvm::ArrayType* names_ty = llvm::ArrayType::get(ptr_ty, arg_names.size());
-        std::vector<llvm::Constant*> name_ptrs;
-        for (const auto& arg : arg_names) {
-            name_ptrs.push_back(llvm::cast<llvm::Constant>(cstring(arg)));
+    llvm::Value* gen_algo_value(const std::shared_ptr<Node>& node, const std::string& name,
+                                bool define_global) {
+        std::vector<std::string> arg_names;
+        for (const auto& tok : node->get_toks()) {
+            arg_names.push_back(tok->get_value());
+        }
+
+        llvm::Function* fn = emit_algo_function(node, name);
+        if (fn == nullptr) {
+            return nullptr;
         }
-        auto* names_global =
-            new llvm::GlobalVariable(module, names_ty, true, llvm::GlobalValue::PrivateLinkage,
-                                     llvm::ConstantArray::get(names_ty, name_ptrs), "args");
+
         bool memoizable = is_memoizable_numeric_algo(node, name, arg_names);
-        return builder.CreateCall(
-            get_rt("rt_define_algo", ptr_ty, {ptr_ty, ptr_ty, ptr_ty, i64_ty, i64_ty}),
-            {cstring(name), fn, names_global,
-             builder.getInt64(static_cast<int64_t>(arg_names.size())),
-             builder.getInt64(memoizable ? 1 : 0)});
+        std::string rt_name = define_global ? "rt_define_algo" : "rt_make_algo";
+        return builder.CreateCall(get_rt(rt_name, ptr_ty, {ptr_ty, ptr_ty, ptr_ty, i64_ty, i64_ty}),
+                                  {cstring(name), fn, string_array(arg_names, "args"),
+                                   builder.getInt64(static_cast<int64_t>(arg_names.size())),
+                                   builder.getInt64(memoizable ? 1 : 0)});
+    }
+
+    llvm::Value* gen_algo_def(const std::shared_ptr<Node>& node) {
+        std::string name = node->get_name();
+        size_t scope = name.find("::");
+        if (scope == std::string::npos) {
+            // Registration happens at the definition site, like visit_algo_def.
+            return gen_algo_value(node, name, true);
+        }
+
+        std::string struct_name = name.substr(0, scope);
+        std::string method_name = name.substr(scope + 2);
+        llvm::Value* method = gen_algo_value(node, name, true);
+        if (method == nullptr) {
+            return nullptr;
+        }
+        builder.CreateCall(get_rt("rt_struct_add_method", ptr_ty, {ptr_ty, ptr_ty, ptr_ty}),
+                           {cstring(struct_name), cstring(method_name), method});
+        return method;
     }
 
     llvm::Value* gen_algo_call(const std::shared_ptr<Node>& node) {
@@ -607,6 +648,32 @@ class CodeGen {
             {callee, argv, builder.getInt64(static_cast<int64_t>(args.size()))});
     }
 
+    llvm::Value* gen_struct_def(const std::shared_ptr<Node>& node) {
+        std::vector<std::string> member_names;
+        for (const auto& tok : node->get_toks()) {
+            member_names.push_back(tok->get_value());
+        }
+
+        std::vector<std::string> method_names;
+        std::vector<llvm::Value*> methods;
+        for (const auto& method_node : node->get_child()) {
+            std::string method_name = method_node->get_name();
+            llvm::Value* method = gen_algo_value(method_node, method_name, false);
+            if (method == nullptr) {
+                return nullptr;
+            }
+            method_names.push_back(method_name);
+            methods.push_back(method);
+        }
+
+        return builder.CreateCall(
+            get_rt("rt_define_struct", ptr_ty, {ptr_ty, ptr_ty, i64_ty, ptr_ty, ptr_ty, i64_ty}),
+            {cstring(node->get_name()), string_array(member_names, "members"),
+             builder.getInt64(static_cast<int64_t>(member_names.size())),
+             string_array(method_names, "method.names"), value_array(methods),
+             builder.getInt64(static_cast<int64_t>(methods.size()))});
+    }
+
     /// ---- arrays, hash tables, members ----
 
     llvm::Value* gen_array(const std::shared_ptr<Node>& node) {
diff --git a/src/pseudo.cpp b/src/pseudo.cpp
index e2d69da..80ed2f9 100644
--- a/src/pseudo.cpp
+++ b/src/pseudo.cpp
@@ -759,18 +759,17 @@ std::shared_ptr<Value> BoundMethodValue::execute(const NodeList& args, SymbolTab
         // Find method
         if (inst_obj->struct_def->methods.count(method_name)) {
             std::shared_ptr<Value> method = inst_obj->struct_def->methods[method_name];
-            // method is likely AlgoValue.
-            // We need to execute it with 'self' in scope.
-            // We can use the existing AlgoValue::execute, but we need to inject
-            // 'self'. Since AlgoValue::execute creates a new symbol table, we can't
-            // inject it easily from outside *before* it starts unless we modify it or
-            // subclass it. However, we can create a new AlgoValue or wrapper that
-            // injects 'self'.
-
-            // Actually, let's copy the logic of AlgoValue::execute here but add self.
             AlgoValue* algo_val = dynamic_cast<AlgoValue*>(method.get());
-            if (!algo_val)
-                return std::make_shared<ErrorValue>(VALUE_ERROR, "Method is not an algorithm");
+            if (!algo_val) {
+                if (method->get_type() != VALUE_ALGO) {
+                    return std::make_shared<ErrorValue>(VALUE_ERROR, "Method is not an algorithm");
+                }
+                // Compiled struct methods use their own execute path, with
+                // `self` provided by this parent binding scope.
+                SymbolTable sym(parent);
+                sym.set("self", obj);
+                return method->execute(args, &sym);
+            }
 
             SymbolTable sym(parent);
             ScopeCleaner cleaner(sym);
diff --git a/src/runtime.cpp b/src/runtime.cpp
index e54b83e..cf3363d 100644
--- a/src/runtime.cpp
+++ b/src/runtime.cpp
@@ -7,6 +7,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
+#include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -82,7 +83,40 @@ std::string numeric_args_key(const ValueList& values) {
     return key;
 }
 
-std::shared_ptr<Value> call_compiled(CompiledAlgoValue* algo, const ValueList& args) {
+std::shared_ptr<Value> make_compiled_algo(const char* name, Value* (*fn)(),
+                                          const char* const* arg_names, int64_t nargs,
+                                          int64_t memoizable) {
+    std::vector<std::string> names;
+    names.reserve(nargs);
+    for (int64_t i = 0; i < nargs; ++i) {
+        names.emplace_back(arg_names[i]);
+    }
+    return std::make_shared<CompiledAlgoValue>(name, fn, std::move(names), memoizable != 0);
+}
+
+void run_scope_destructors(SymbolTable& scope) {
+    if (!scope.has_instances()) {
+        return;
+    }
+    for (const auto& [name, val] : scope.get_symbols()) {
+        (void)name;
+        if (val->get_type() != VALUE_INSTANCE || val.use_count() != 1) {
+            continue;
+        }
+        InstanceValue* inst = dynamic_cast<InstanceValue*>(val.get());
+        std::shared_ptr<Value> self_ptr = val;
+        std::shared_ptr<Value> dtor = inst->get_member("destructor", self_ptr);
+        if (dtor->get_type() == VALUE_ALGO) {
+            std::shared_ptr<Value> ret = dtor->execute({}, scope.get_parent());
+            if (ret->get_type() == VALUE_ERROR) {
+                rt_fail(ret);
+            }
+        }
+    }
+}
+
+std::shared_ptr<Value> call_compiled(CompiledAlgoValue* algo, const ValueList& args,
+                                     SymbolTable* parent = nullptr) {
     if (args.size() < algo->arg_names.size()) {
         return std::make_shared<ErrorValue>(
             VALUE_ERROR, Color(0xFF, 0x39, 0x6E).get() + "Too few arguments" RESET);
@@ -105,14 +139,15 @@ std::shared_ptr<Value> call_compiled(CompiledAlgoValue* algo, const ValueList& a
 
     int64_t mark = rt_frame_mark();
     rt_frame_push();
-    scopes.push_back(std::make_unique<SymbolTable>(&current_scope()));
+    scopes.push_back(std::make_unique<SymbolTable>(parent != nullptr ? parent : &current_scope()));
     for (size_t i = 0; i < args.size(); ++i) {
         scopes.back()->set(algo->arg_names[i], args[i]);
     }
     Value* result = algo->fn();
     std::shared_ptr<Value> kept = ref(result);
-    scopes.pop_back();
     rt_frame_release(mark);
+    run_scope_destructors(*scopes.back());
+    scopes.pop_back();
     if (!memo_key.empty() && (kept->get_type() == VALUE_INT || kept->get_type() == VALUE_FLOAT)) {
         algo->memo[memo_key] = kept;
     }
@@ -131,7 +166,7 @@ std::shared_ptr<Value> CompiledAlgoValue::execute(const NodeList& args, SymbolTa
         }
         evaluated.push_back(v);
     }
-    return call_compiled(this, evaluated);
+    return call_compiled(this, evaluated, &sym);
 }
 
 }  // namespace
@@ -296,19 +331,44 @@ Value* rt_member_assign(Value* obj, const char* name, Value* v) {
         VALUE_ERROR, "Assignment to member only supported for Struct Instances\n"));
 }
 
+Value* rt_make_algo(const char* name, Value* (*fn)(), const char* const* arg_names, int64_t nargs,
+                    int64_t memoizable) {
+    return track(make_compiled_algo(name, fn, arg_names, nargs, memoizable));
+}
+
 Value* rt_define_algo(const char* name, Value* (*fn)(), const char* const* arg_names, int64_t nargs,
                       int64_t memoizable) {
-    std::vector<std::string> names;
-    names.reserve(nargs);
-    for (int64_t i = 0; i < nargs; ++i) {
-        names.emplace_back(arg_names[i]);
-    }
-    std::shared_ptr<Value> algo =
-        std::make_shared<CompiledAlgoValue>(name, fn, std::move(names), memoizable != 0);
+    std::shared_ptr<Value> algo = make_compiled_algo(name, fn, arg_names, nargs, memoizable);
     current_scope().set(name, algo);
     return track(algo);
 }
 
+Value* rt_define_struct(const char* name, const char* const* member_names, int64_t nmembers,
+                        const char* const* method_names, Value** methods, int64_t nmethods) {
+    std::vector<std::string> members;
+    members.reserve(nmembers);
+    for (int64_t i = 0; i < nmembers; ++i) {
+        members.emplace_back(member_names[i]);
+    }
+
+    std::map<std::string, std::shared_ptr<Value>> method_map;
+    for (int64_t i = 0; i < nmethods; ++i) {
+        method_map[method_names[i]] = ref(methods[i]);
+    }
+
+    std::shared_ptr<Value> struct_value = std::make_shared<StructValue>(name, members, method_map);
+    current_scope().set(name, struct_value);
+    return track(struct_value);
+}
+
+Value* rt_struct_add_method(const char* struct_name, const char* method_name, Value* method) {
+    std::shared_ptr<Value> struct_value = current_scope().get(struct_name);
+    if (struct_value->get_type() == VALUE_STRUCT) {
+        dynamic_cast<StructValue*>(struct_value.get())->methods[method_name] = ref(method);
+    }
+    return track(ref(method));
+}
+
 Value* rt_call(Value* callee, Value** argv, int64_t argc) {
     ValueList args;
     args.reserve(argc);
diff --git a/src/runtime.h b/src/runtime.h
index d22d792..b2abacc 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -75,8 +75,13 @@ Value* rt_member_assign(Value* obj, const char* name, Value* v);
 
 // `memoizable` enables the same by-argument result caching the interpreter
 // applies to recursive pure-numeric algorithms.
+Value* rt_make_algo(const char* name, Value* (*fn)(), const char* const* arg_names, int64_t nargs,
+                    int64_t memoizable);
 Value* rt_define_algo(const char* name, Value* (*fn)(), const char* const* arg_names, int64_t nargs,
                       int64_t memoizable);
+Value* rt_define_struct(const char* name, const char* const* member_names, int64_t nmembers,
+                        const char* const* method_names, Value** methods, int64_t nmethods);
+Value* rt_struct_add_method(const char* struct_name, const char* method_name, Value* method);
 Value* rt_call(Value* callee, Value** argv, int64_t argc);
 
 int64_t rt_frame_mark();
diff --git a/test/compiler_tests.sh b/test/compiler_tests.sh
index bc89477..64dbd67 100755
--- a/test/compiler_tests.sh
+++ b/test/compiler_tests.sh
@@ -24,6 +24,7 @@ FILES=(
     "$ROOT/test/test_repeat.ps"
     "$ROOT/test/test_array_methods.ps"
     "$ROOT/test/test_string_index.ps"
+    "$ROOT/test/test_struct.ps"
 )
 
 failures=0
@@ -50,18 +51,6 @@ for src in "${FILES[@]}"; do
     fi
 done
 
-# Struct programs must be rejected at compile time with a clear message.
-if "$PSEUDOC" "$ROOT/test/test_struct.ps" -o "$WORKDIR/struct.bin" > "$WORKDIR/struct.out" 2>&1; then
-    echo "FAIL struct-rejection: expected compile error"
-    failures=$((failures + 1))
-elif ! grep -q "Struct is not supported" "$WORKDIR/struct.out"; then
-    echo "FAIL struct-rejection: wrong error message"
-    sed 's/^/    /' "$WORKDIR/struct.out"
-    failures=$((failures + 1))
-else
-    echo "PASS struct-rejection"
-fi
-
 if [[ $failures -ne 0 ]]; then
     echo "$failures test(s) failed"
     exit 1

From d53773a7aa77c3d36283b9ea42389e43bd215d63 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 22:44:23 +0800
Subject: [PATCH 11/12] chore: remove tracked pseudoc binary

---
 .gitignore |   1 +
 pseudoc    | Bin 845032 -> 0 bytes
 2 files changed, 1 insertion(+)
 delete mode 100755 pseudoc

diff --git a/.gitignore b/.gitignore
index 29beb8d..5e5b306 100644
--- a/.gitignore
+++ b/.gitignore
@@ -32,6 +32,7 @@
 *.app
 shell
 pseudo
+pseudoc
 pseudo-lsp
 run_tests
 
diff --git a/pseudoc b/pseudoc
deleted file mode 100755
index 333112da4675b96d2bd501adfbc4dce4ca2f2bb9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 845032
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%0A*kFo@nJ%?_
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
Y$T5oM<G<GZe6_ev7g6agB46|W08HkjxBvhE


From 0bbf1e740655b39f5c1ee7ffba9b0beb92092246 Mon Sep 17 00:00:00 2001
From: mtmatt <mtmattqq@gmail.com>
Date: Wed, 10 Jun 2026 23:59:41 +0800
Subject: [PATCH 12/12] style: fix node destructor formatting

---
 src/node.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/node.h b/src/node.h
index 4f8f779..c717192 100644
--- a/src/node.h
+++ b/src/node.h
@@ -41,7 +41,7 @@ class Node {
    public:
     Node() : node_id(next_node_id.fetch_add(1, std::memory_order_relaxed)) {}
     virtual std::string get_node() = 0;
-    virtual ~Node() {};
+    virtual ~Node() {}
     virtual std::vector<std::shared_ptr<Node>> get_child() {
         return std::vector<std::shared_ptr<Node>>(0);
     }