显示指定构建target为 Fig

[Fix] 函数调用时参数类型求值使用错误作用域的问题
[Fix] 结构体定义中不可以使用自身类型的bug
[Fix] import导致的重定义bug
[Impl] Parser的precedence调整

[Feat] 支持运算符重载, impl Operator for xxx {} 具体见 lang.fig中解释
[Feat] 新增标准库 std.test
[Feat] 新增内置函数 type，接收一个参数，返回该参数的类型(value.type改名value._type)
        推荐使用该函数替换 value._type
[Feat] 新增转换运算符 as，转换失败时抛出TypeError，支持任意类型到String、部分类型到Int, Double等等转换
        TypeError实现了Error interface，可被用户catch
        推荐使用该feat或与std.value标准库结合
[Feat] 抛出实现Error interface的错误现在会有不一样的log
[Feat] import增加cache(ast + source lines)，但import一个module每次会得到不同对象而不是复用，请注意

.gitea/workflows/build.yml

@@ -43,7 +43,7 @@ jobs:
         run: |
           echo "开始构建Linux版本..."
           xmake f -p linux -a x86_64 -m release -y
-          xmake build -j$(nproc)
+          xmake build -j$(nproc) Fig
           echo "Linux构建成功。"
 
       # 🔧 新增：构建Linux平台安装器
@@ -169,7 +169,7 @@ jobs:
       - name: 构建项目 (Windows Native)
         run: |
           xmake f -p windows -a x86_64 -m release -y
-          xmake build -j $env:NUMBER_OF_PROCESSORS
+          xmake build -j $env:NUMBER_OF_PROCESSORS Fig
           Write-Host 'Windows构建成功。'
 
       # 🔧 新增：构建Windows平台安装器

ExampleCodes/1-Variables.fig

@@ -10,4 +10,70 @@ invalid!
 */
 
 const Pi := 3.14; // recommended, auto detect type
-// equal -> const Pi: Double = 3.14;
+// equal -> const Pi: Double = 3.14;
+
+/*
+In fig, we have 13 builtin-type
+
+01  Any
+02  Null
+03  Int
+04  String
+05  Bool
+06  Double
+07  Function
+08  StructType
+09  StructInstance
+10  List
+11  Map
+12  Module
+13  InterfaceType
+
+3, 4, 5, 6, 10, 11 are initable
+
+value system:
+    object is immutable
+    (included basic types: Int, String...)
+
+    `variable` is a name, refers to an object
+    assignment is to bind name to value
+    
+    Example: var a := 10;
+
+    [name] 'a' ---> variable slot (name, declared type, access modifier, [value) ---> ObjectPtr ---> raw Object class
+               bind                                                              bind (shared_ptr)
+
+    For example:
+        var a := 10;
+        var b := 10;
+
+        `a` and `b` reference to the same object in memory
+
+        a = 20;
+
+        now a refers to a new object (20, Int)
+
+        what about complex types?
+        they actually have same behaviors with basic types
+
+        var a := [1, 2, 3, 4];
+        var b := a;
+
+        > a
+          [1, 2, 3, 4]
+        > b
+          [1, 2, 3, 4]
+        
+        set a[0] to 5
+
+        > a
+          [5, 2, 3, 4]
+        > b
+          [5, 2, 3, 4]
+
+        Why did such a result occur?
+    
+        " `a` and `b` reference to the same object in memory "
+
+        If you wish to obtain a copy, use List {a} to deeply copy it
+*/

ExampleCodes/FigFig/main.fig

@@ -0,0 +1,4 @@
+import std.io;
+
+import token {Token, TokenType};
+import tokenizer {Tokenizer};

ExampleCodes/FigFig/token.fig

@@ -0,0 +1,31 @@
+/*
+Example code: FigFig
+
+Token.fig
+Copyright (C) 2020-2026 PuqiAR
+
+*/
+struct _TokenTypes
+{
+    public EOF = -1;
+    public Identifier = 0;
+
+    public StringLiteral = 1;
+    public NumberLiteral = 2;
+    public True = 3;
+    public False = 4;
+    public Null = 5;
+    
+    public Plus = 6;
+    public Minus = 7;
+    public Asterisk = 8;
+    public Slash = 9;
+}
+
+public const TokenType := new _TokenTypes{};
+
+public struct Token
+{
+    public literal: String = "";
+    public type: Int = TokenType.EOF;
+} 

ExampleCodes/FigFig/tokenizer.fig

@@ -0,0 +1,20 @@
+/*
+Example code: FigFig
+
+Tokenizer.fig
+Copyright (C) 2020-2026 PuqiAR
+
+*/
+
+import token {Token, TokenType};
+
+public struct Tokenizer
+{
+    src: String = "";
+
+    public func TokenizeAll() -> List
+    {
+        var output := [];
+        return output;
+    }
+}

ExampleCodes/SpeedTest/fibBenchmark.fig

@@ -0,0 +1,84 @@
+import std.io;
+import std.time;
+import std.value;
+
+func benchmark(fn: Function, arg: Any) -> Null
+{
+    io.println("Testing fn:", fn, "with arg:", arg);
+    const start := time.now();
+    
+    const result := fn(arg);
+    
+    const end := time.now();
+    const duration := new time.Time{
+        end.since(start)
+    };
+    io.println("=" * 50);
+    io.println("fn returns:", result, "\n");
+    io.println("Cost:", duration.toSeconds(), "s");
+    io.println("     ", duration.toMillis(), "ms");
+}
+
+var memo := {};
+
+func fib_memo(x)
+{
+    if memo.contains(x)
+    {
+        return memo.get(x);
+    }
+    if x <= 1
+    {
+        memo[x] = x;
+        return x;
+    }
+    var result := fib_memo(x - 1) + fib_memo(x - 2);
+    memo[x] = result;
+    return result;
+}
+
+func fib_iter(n)
+{
+    var a := 0;
+    var b := 1;
+    for var i := 0; i < n; i = i + 1
+    {
+        var temp := a + b;
+        a = b;
+        b = temp;
+    }
+    return a;
+}
+
+func fib(x)
+{
+    if x <= 1
+    {
+        return x;
+    }
+    return fib(x - 1) + fib(x - 2);
+}
+
+func fib_tail(n, a=0, b=1) {
+    if n == 0 { return a; }
+    if n == 1 { return b; }
+    return fib_tail(n-1, b, a+b);
+}
+
+const n := 30;
+
+io.println("! fib(" + value.string_from(n) + "):");
+benchmark(fib, n);
+io.print("\n\n");
+
+io.println("! fib_memo(" + value.string_from(n) + "):");
+benchmark(fib_memo, n);
+io.print("\n\n");
+
+io.println("! fib_iter(" + value.string_from(n) + "):");
+benchmark(fib_iter, n);
+io.print("\n\n");
+
+io.println("! fib_tail(" + value.string_from(n) + "):");
+benchmark(fib_tail, n);
+io.print("\n\n");

ExampleCodes/use_std_time.fig

@@ -0,0 +1,29 @@
+import std.io;
+import std.test;
+
+var ascii_string_test := new test.Test{
+    "ascii_string_test",
+    func () => io.println("Hello," + " world!"),
+    2
+};
+
+var unicode_string_test := new test.Test{
+    "unicode_string_test",
+    func () => io.println("你好," + " 世界!"),
+    2
+};
+
+var unicode_string_inserting_test := new test.Test{
+    "unicode_string_inserting_test",
+    func (){
+        var str := "我是你的粑粑";
+        str.insert(1, "不");
+        return str;
+    },
+    "我不是你的粑粑"
+};
+
+var tests := [ascii_string_test, unicode_string_test, unicode_string_inserting_test];
+
+var tester := new test.Tester{tests};
+tester.TestAll();

README.md

@@ -1,15 +1,18 @@
 # Fig Language - A Modern Scripting Language
 
 [Fig-Gitea](https://git.fig-lang.cn/PuqiAR/Fig)
+Recommend view on Gitea Endpoint
 
 [简体中文](README_ZH-CN.md "Chinese version")
 
-**Fig** is a statically-typed, expression-oriented programming language designed for clarity, safety, and modern development practices. With features inspired by Go, Rust, and JavaScript, Fig aims to provide a productive development experience while maintaining strong type safety.
+**Fig** is a dynamically strongly typed programming language designed for clarity, safety, and modern development practices. With features inspired by Go, Rust, and JavaScript, Fig aims to provide a productive development experience while maintaining strong type safety.
+
+[LanguageTutorial(zh_CN)](docs/zh_CN/01-简介.md "Chinese version")
 
 ## Features
 
 ### 🚀 Core Language Features
-- **Static typing with type inference** - Strong typing with minimal annotations
+- **Dynamic typing with type inference** - Strong typing with minimal annotations
 - **Modern control flow** - Full `for` loop support with proper scoping
 - **First-class functions** - Lambda expressions and closures
 - **Rich data structures** - Structs, lists, maps, and tuples
@@ -55,35 +58,6 @@ xmake run Fig [file]
 
 Replace `[file]` with the path to your input file.
 
-### 📁 Project Structure
-.
-├── ExampleCodes                # Example programs & performance tests
-│   └── SpeedTest               # Performance benchmark samples
-├── LICENSE                     # Project license
-├── Logo                        # Project logo assets
-├── README.md                   # English README
-├── README_ZH-CN.md             # Chinese README
-├── compile_flags.txt           # Compiler flags helper
-├── fig-vscode                  # VSCode extension project
-│   ├── node_modules            # Extension dependencies
-│   ├── out                     # Built extension output
-│   ├── src                     # Extension source code
-│   └── syntaxes                # Syntax highlighting definition
-├── src                         # Core Fig language source
-│   ├── Ast                     # AST definitions
-│   ├── Context                 # Runtime context
-│   ├── Core                    # Core utilities (UTF8/string/etc.)
-│   ├── Error                   # Error handling system
-│   ├── Evaluator               # Interpreter / evaluator
-│   ├── Lexer                   # Lexical analyzer
-│   ├── Module                  # Modules and builtins
-│   ├── Parser                  # Parser
-│   ├── Token                   # Token definitions
-│   ├── Utils                   # Utilities & helper headers
-│   └── Value                   # Runtime type/value system
-├── test.fig                    # Test script
-└── xmake.lua                   # Xmake build config
-
 ## Language Philosophy
     Fig is designed around several core principles:
 
@@ -93,4 +67,34 @@ Replace `[file]` with the path to your input file.
 
     Modern ergonomics - Developer experience matters
 
-    Gradual learning - Simple to start, powerful when needed
+    Gradual learning - Simple to start, powerful when needed
+
+## Performance Summary
+
+**Version:** 0.4.2-alpha (Tree-walker Interpreter)  
+**Test Hardware:** i5-13490F, Windows 11
+
+**Execution Times for Fibonacci(30):**
+- Naive Recursion: **11.72s**
+- Memoization: **0.93ms** (12,600× faster)
+- Iteration: **0.37ms** (31,300× faster)  
+- Tail Recursion: **0.40ms** (29,200× faster)
+
+**Visual Comparison:**
+```
+Naive Recursion  : ████████████████████████████████████████ 11.72s
+Memoization      : ▉ 0.93ms
+Iteration        : ▍ 0.37ms
+Tail Recursion   : ▎ 0.40ms
+```
+
+**Key Insight:** Algorithm choice dominates performance in this tree-walker implementation.
+
+**Detailed Reports:** [English](./docs/benchmark_result/benchmark_result_en_0.4.2-alpha.md) | [中文](./docs/benchmark_result/benchmark_result_zh_0.4.2-alpha.md)
+
+
+## Language Documents
+
+see ./docs/en_US/...
+
+We're looking for translators to help translate our project and make it accessible to more language communities.

README_ZH-CN.md

@@ -4,12 +4,14 @@
 
 [English](README.md "英文版本")
 
-**Fig** 是一种静态类型、面向表达式的编程语言，专为清晰性、安全性和现代开发实践而设计。Fig 融合了 Go、Rust 和 JavaScript 的灵感，旨在提供高效的开发体验，同时保持强大的类型安全。
+**Fig** 是一种动态强类型的编程语言，专为清晰性、安全性和现代开发实践而设计。Fig 融合了 Go、Rust 和 JavaScript 的灵感，旨在提供高效的开发体验，同时保持强大的类型安全。
+
+[语言入门教程(zh_CN)](docs/zh_CN/01-简介.md "第一章")
 
 ## 特性
 
 ### 🚀 核心语言特性
-- **静态类型与类型推断** - 强类型系统，最少类型注解
+- **动态类型与类型推断** - 强类型系统，最少类型注解
 - **现代控制流** - 完整的 `for` 循环支持，正确的作用域管理
 - **一等公民函数** - Lambda 表达式和闭包
 - **丰富的数据结构** - 结构体、列表、映射和元组
@@ -42,47 +44,43 @@ xmake build Fig
 
 4. 运行程序：
 
-
-
 ```bash
 xmake run Fig [file]
 ```
 将`[file]`替换为输入文件的路径。
 
-### 📁 项目结构
-.
-├── ExampleCodes                # 示例代码与性能测试样例
-│   └── SpeedTest               # 性能相关测试示例
-├── LICENSE                     # 项目开源协议
-├── Logo                        # 项目标识资源
-├── README.md                   # 英文 README
-├── README_ZH-CN.md             # 中文 README
-├── compile_flags.txt           # C/C++ 编译器参数提示
-├── fig-vscode                  # VSCode 插件项目
-│   ├── node_modules            # VSCode 插件依赖
-│   ├── out                     # 构建产物
-│   ├── src                     # VSCode 插件源码
-│   └── syntaxes                # 语法高亮定义
-├── src                         # Fig 语言核心源码
-│   ├── Ast                     # 抽象语法树节点
-│   ├── Context                 # 运行上下文
-│   ├── Core                    # 核心基础设施（字符串/UTF8 等）
-│   ├── Error                   # 错误系统
-│   ├── Evaluator               # 解释执行器
-│   ├── Lexer                   # 词法分析器
-│   ├── Module                  # 模块与内置库
-│   ├── Parser                  # 语法解析器
-│   ├── Token                   # Token 定义
-│   ├── Utils                   # 实用工具与第三方 header
-│   └── Value                   # 运行时类型系统与值表示
-├── test.fig                    # 测试脚本
-└── xmake.lua                   # Xmake 构建脚本
-
-
 ## 语言设计哲学
 Fig 围绕几个核心原则设计：
 
 1. **清晰优于巧妙** - 代码首先应该可读
 2. **默认为安全** - 在编译时防止常见错误
 3. **现代人机工程学** - 开发者体验很重要
-4. **渐进式学习** - 入门简单，需要时功能强大
+4. **渐进式学习** - 入门简单，需要时功能强大
+
+## 性能概览
+
+**版本:** 0.4.2-alpha (树遍历解释器)  
+**测试硬件:** i5-13490F, Windows 11
+
+**计算 Fibonacci(30) 的执行时间:**
+- 朴素递归: **11.72秒**
+- 记忆化: **0.93毫秒** (快12,600倍)
+- 迭代: **0.37毫秒** (快31,300倍)
+- 尾递归: **0.40毫秒** (快29,200倍)
+
+**可视化对比:**
+```
+朴素递归      : ████████████████████████████████████████ 11.72秒
+记忆化递归    : ▉ 0.93毫秒
+迭代算法      : ▍ 0.37毫秒
+尾递归        : ▎ 0.40毫秒
+```
+
+**核心发现:** 在此树遍历实现中，算法选择主导性能表现。
+
+**详细报告:** [English](./docs/benchmark_result/benchmark_result_en_0.4.2-alpha.md) | [中文](./docs/benchmark_result/benchmark_result_zh_0.4.2-alpha.md)
+
+
+## 语言文档
+在 docs/zh_CN/... 查看更多
+我们正在寻找译者来帮助翻译项目文件以便于不同语言社区的使用

docs/benchmark_result/benchmark_result_en_0.4.2-alpha.md

@@ -0,0 +1,117 @@
+# Fig Language Performance Benchmark Report
+
+## Version: 0.4.2-alpha (Tree-walker Interpreter)
+
+### Test Environment
+- **CPU:** Intel Core i5-13490F
+- **OS:** Windows 11
+- **Compiler/Interpreter:** Fig Tree-walker v0.4.2-alpha
+- **Test Date:** Current test execution
+
+### Executive Summary
+This benchmark evaluates the performance of four different Fibonacci algorithm implementations in Fig language, calculating the 30th Fibonacci number (832,040). The results demonstrate significant performance variations based on algorithmic approach, highlighting the interpreter's efficiency characteristics.
+
+## Performance Results
+
+### Raw Execution Times
+
+| Algorithm                   | Time (seconds) | Time (milliseconds) | Relative Speed   |
+| --------------------------- | -------------- | ------------------- | ---------------- |
+| `fib` (Naive Recursion)     | 11.7210479 s   | 11721.0479 ms       | 1.00× (baseline) |
+| `fib_memo` (Memoization)    | 0.0009297 s    | 0.9297 ms           | 12,600× faster   |
+| `fib_iter` (Iterative)      | 0.0003746 s    | 0.3746 ms           | 31,300× faster   |
+| `fib_tail` (Tail Recursion) | 0.0004009 s    | 0.4009 ms           | 29,200× faster   |
+
+### Visual Performance Comparison
+```
+Naive Recursion  : ████████████████████████████████████████ 11.72s
+Memoization      : ▉ 0.93ms
+Iteration        : ▍ 0.37ms
+Tail Recursion   : ▎ 0.40ms
+```
+
+## Detailed Analysis
+
+### 1. Naive Recursive Implementation (`fib`)
+- **Time:** 11.721 seconds (11,721 ms)
+- **Algorithm Complexity:** O(2ⁿ) exponential
+- **Performance Notes:** 
+  - Demonstrates the high cost of repeated function calls in tree-walker interpreters
+  - Shows exponential time complexity with just n=30
+  - Highlights the need for algorithmic optimization in interpreted languages
+
+### 2. Memoized Recursive Implementation (`fib_memo`)
+- **Time:** 0.93 milliseconds
+- **Algorithm Complexity:** O(n) linear (with memoization overhead)
+- **Performance Notes:**
+  - 12,600× speedup over naive recursion
+  - Shows efficient hash table/dictionary operations in Fig
+  - Demonstrates that caching can overcome interpreter overhead
+
+### 3. Iterative Implementation (`fib_iter`)
+- **Time:** 0.375 milliseconds
+- **Algorithm Complexity:** O(n) linear
+- **Performance Notes:**
+  - Fastest implementation (31,300× faster than naive)
+  - Shows efficient loop execution and variable operations
+  - Minimal function call overhead
+
+### 4. Tail Recursive Implementation (`fib_tail`)
+- **Time:** 0.401 milliseconds
+- **Algorithm Complexity:** O(n) linear
+- **Performance Notes:**
+  - Comparable to iterative approach (slightly slower due to recursion overhead)
+  - Current interpreter does not implement Tail Call Optimization (TCO)
+  - Shows linear recursion is efficient for moderate depths (n=30)
+
+## Technical Insights
+
+### Interpreter Performance Characteristics
+1. **Function Call Overhead:** Significant, as shown by the naive recursion performance
+2. **Loop Efficiency:** Excellent, with iterative approaches performing best
+3. **Memory Access:** Hash table operations (memoization) are efficient
+4. **Recursion Depth:** Linear recursion (tail recursion) performs well up to moderate depths
+
+### Algorithmic Impact
+The benchmark clearly demonstrates that **algorithm choice has a greater impact than interpreter optimization** in this version:
+- Poor algorithm (naive recursion): 11.7 seconds
+- Good algorithm (any O(n) approach): < 1 millisecond
+
+## Version-Specific Observations (v0.4.2-alpha)
+
+### Strengths
+- Excellent performance for iterative algorithms
+- Efficient basic operations (arithmetic, loops, conditionals)
+- Effective memory access patterns for cached results
+- Linear recursion performance acceptable for typical use cases
+
+### Areas for Improvement
+- High function call overhead in deeply recursive scenarios
+- No tail call optimization implemented
+- Exponential algorithm performance shows interpreter limits
+
+## Recommendations for Developers
+
+1. **Prefer iterative solutions** for performance-critical code
+2. **Use memoization** for recursive problems with overlapping subproblems
+3. **Tail recursion is acceptable** for linear recursion patterns
+4. **Avoid exponential algorithms** in interpreted code
+5. **Benchmark different approaches** as algorithmic choice dominates performance
+
+## Conclusion
+
+Fig v0.4.2-alpha demonstrates **practical performance for well-designed algorithms**. While the tree-walker interpreter has inherent overhead for certain patterns (like deep recursion), it executes efficient O(n) algorithms with sub-millisecond performance for n=30.
+
+The interpreter shows particular strength in:
+- Iterative loop execution
+- Basic arithmetic and control flow
+- Dictionary/table operations for caching
+
+The performance characteristics are suitable for a wide range of application domains, provided developers employ standard algorithmic optimization techniques.
+
+---
+
+**Report Generated:** Based on actual benchmark execution  
+**Interpreter Type:** Tree-walker  
+**Version:** 0.4.2-alpha  
+**Key Takeaway:** Algorithmic efficiency dominates performance; Fig executes optimized algorithms efficiently despite being an alpha-stage tree-walker interpreter.

docs/benchmark_result/benchmark_result_zh_0.4.2-alpha.md

@@ -0,0 +1,117 @@
+# Fig 语言性能基准测试报告
+
+## 版本: 0.4.2-alpha (树遍历解释器)
+
+### 测试环境
+- **CPU:** Intel Core i5-13490F
+- **操作系统:** Windows 11
+- **编译器/解释器:** Fig 树遍历解释器 v0.4.2-alpha
+- **测试日期:** 当前测试执行
+
+### 执行摘要
+本基准测试评估了 Fig 语言中四种不同斐波那契算法实现的性能，计算第30个斐波那契数（832,040）。结果显示基于算法方法的显著性能差异，突出了解释器的效率特性。
+
+## 性能结果
+
+### 原始执行时间
+
+| 算法                | 时间(秒)     | 时间(毫秒)    | 相对速度     |
+| ------------------- | ------------ | ------------- | ------------ |
+| `fib` (朴素递归)    | 11.7210479 s | 11721.0479 ms | 1.00× (基准) |
+| `fib_memo` (记忆化) | 0.0009297 s  | 0.9297 ms     | 12,600× 更快 |
+| `fib_iter` (迭代)   | 0.0003746 s  | 0.3746 ms     | 31,300× 更快 |
+| `fib_tail` (尾递归) | 0.0004009 s  | 0.4009 ms     | 29,200× 更快 |
+
+### 可视化性能对比
+```
+朴素递归      : ████████████████████████████████████████ 11.72秒
+记忆化递归    : ▉ 0.93毫秒
+迭代算法      : ▍ 0.37毫秒
+尾递归        : ▎ 0.40毫秒
+```
+
+## 详细分析
+
+### 1. 朴素递归实现 (`fib`)
+- **时间:** 11.721 秒 (11,721 毫秒)
+- **算法复杂度:** O(2ⁿ) 指数级
+- **性能说明:**
+  - 展示了树遍历解释器中重复函数调用的高成本
+  - 在仅 n=30 的情况下显示了指数时间复杂度
+  - 突出了解释型语言中算法优化的必要性
+
+### 2. 记忆化递归实现 (`fib_memo`)
+- **时间:** 0.93 毫秒
+- **算法复杂度:** O(n) 线性（含记忆化开销）
+- **性能说明:**
+  - 比朴素递归快 12,600 倍
+  - 显示 Fig 中哈希表/字典操作的高效性
+  - 证明缓存可以克服解释器开销
+
+### 3. 迭代实现 (`fib_iter`)
+- **时间:** 0.375 毫秒
+- **算法复杂度:** O(n) 线性
+- **性能说明:**
+  - 最快的实现（比朴素递归快 31,300 倍）
+  - 显示高效的循环执行和变量操作
+  - 函数调用开销最小
+
+### 4. 尾递归实现 (`fib_tail`)
+- **时间:** 0.401 毫秒
+- **算法复杂度:** O(n) 线性
+- **性能说明:**
+  - 与迭代方法相当（由于递归开销略慢）
+  - 当前解释器未实现尾调用优化（TCO）
+  - 显示线性递归在中等深度（n=30）下是高效的
+
+## 技术洞察
+
+### 解释器性能特征
+1. **函数调用开销:** 显著，如朴素递归性能所示
+2. **循环效率:** 优秀，迭代方法表现最佳
+3. **内存访问:** 哈希表操作（记忆化）高效
+4. **递归深度:** 线性递归（尾递归）在中等深度下表现良好
+
+### 算法影响
+基准测试清楚地表明，**在此版本中，算法选择比解释器优化影响更大**：
+- 差算法（朴素递归）：11.7 秒
+- 好算法（任何 O(n) 方法）：< 1 毫秒
+
+## 版本特定观察 (v0.4.2-alpha)
+
+### 优势
+- 迭代算法性能优秀
+- 基本操作（算术、循环、条件判断）高效
+- 缓存结果的内存访问模式有效
+- 线性递归性能在典型用例中可接受
+
+### 改进空间
+- 深度递归场景中函数调用开销高
+- 未实现尾调用优化
+- 指数算法性能显示解释器限制
+
+## 给开发者的建议
+
+1. **性能关键代码优先使用迭代解决方案**
+2. **对于有重叠子问题的递归问题使用记忆化**
+3. **线性递归模式可接受尾递归**
+4. **避免在解释型代码中使用指数算法**
+5. **基准测试不同方法**，因为算法选择主导性能
+
+## 结论
+
+Fig v0.4.2-alpha 展示了**对设计良好的算法的实用性能**。虽然树遍历解释器对某些模式（如深度递归）有固有开销，但它能以亚毫秒性能执行高效的 O(n) 算法（n=30时）。
+
+解释器在以下方面表现特别出色：
+- 迭代循环执行
+- 基本算术和控制流
+- 用于缓存的字典/表操作
+
+性能特征适用于广泛的应用领域，前提是开发者采用标准的算法优化技术。
+
+---
+
+**报告生成时间:** 基于实际基准测试执行  
+**解释器类型:** 树遍历解释器  
+**版本:** 0.4.2-alpha  
+**关键要点:** 算法效率主导性能；尽管 Fig 是 alpha 阶段的树遍历解释器，但它能高效执行优化算法。

docs/zh_CN/01-简介.md

@@ -0,0 +1,24 @@
+# Fig 语言简介
+
+## 概述
+Fig 是一门动态类型、解释执行的编程语言，专注于简洁语法和实用的语言特性。它采用树遍历解释器架构，支持多种编程范式。
+
+## 实际观察到的特性
+1. **解释执行**：基于 AST 的树遍历解释器，无编译步骤
+2. **动态类型系统**：运行时类型检查，支持类型注解但不强制
+3. **混合范式**：支持函数式、面向对象和命令式风格
+4. **模块系统**：支持代码组织和复用
+5. **内置类型**：整数、浮点数、字符串、列表、映射等
+6. **垃圾回收**：基于引用计数的自动内存管理
+
+## 语言设计特点
+- **渐进类型**：支持类型注解但不强制，兼顾灵活性和可读性
+- **一等公民函数**：函数可以作为参数传递和返回
+- **闭包支持**：完整的词法作用域和闭包
+- **错误处理**：异常机制和 try-catch 结构
+- **可变与不可变**：const/var 区分，平衡安全与灵活
+
+## 目标应用场景
+- 脚本编写和自动化任务
+- 教育用途和学习编程
+- 配置语言和DSL

docs/zh_CN/02-快速开始.md

@@ -0,0 +1,82 @@
+# 快速开始
+
+## 运行 Fig 程序
+
+Fig 语言通过解释器直接执行源代码文件。基本执行命令如下：
+
+`./Fig 你的脚本.fig`
+
+### 查看帮助和版本
+
+显示帮助信息：
+`./Fig -h` 或 `./Fig --help`
+
+显示版本信息：
+`./Fig -v` 或 `./Fig --version`
+
+### 示例
+
+创建一个名为 `hello.fig` 的文件，内容为：
+
+```go
+import std.io;
+io.println("Hello, Fig!");
+```
+
+在终端中运行：
+`./Fig hello.fig`
+
+你会看到输出：`Hello, Fig!`
+
+## 程序示例
+
+### 简单表达式程序
+
+Fig 程序可以只包含表达式：
+
+```go
+1 + 2 * 3
+```
+
+运行此程序会输出计算结果 `7`。
+
+### 带变量的程序
+
+```go
+var x = 10;
+var y = x * 2;
+y + 5
+```
+
+运行输出 `25`。
+
+## 错误处理
+
+当源代码有语法或类型错误时，解释器会显示详细的错误信息。例如：
+
+```rust
+An error occurred! Fig 0.4.2-alpha (2026-01-23 01:30:46)[llvm-mingw 64 bit on `Windows`]
+✖  TypeError: Variable `x` expects init-value type `Int`, but got 'Double'
+    at 1:14 in file 'your_file.fig'
+    var x: Int = 3.14;
+                 ^
+```
+
+错误信息包括：
+- 错误类型和描述
+- 发生错误的文件和位置
+- 相关的堆栈跟踪信息
+
+## 运行流程
+
+1. **编写代码**：使用任何文本编辑器创建 `.fig` 文件
+2. **保存文件**：确保文件扩展名为 `.fig`
+3. **执行程序**：在终端中运行 `./Fig 文件名.fig`
+4. **查看结果**：程序输出显示在终端中
+5. **调试错误**：根据错误信息修改代码
+
+## 注意事项
+
+- Fig 源文件必须使用 UTF-8 编码
+- 语句通常以分号结束，但程序最后一条表达式可以省略分号
+- 文件路径可以包含空格，但建议使用引号包裹：`./Fig "my script.fig"`

docs/zh_CN/03-基础语法.md

@@ -0,0 +1,213 @@
+# 基础语法
+
+## 注释
+
+Fig 支持两种注释格式：
+
+单行注释：
+```go
+// 这是一个单行注释
+var x = 10; // 注释可以在语句后面
+```
+
+多行注释：
+```go
+/* 这是一个
+   多行注释 */
+/* 注释内可以有 // 嵌套的单行注释 */
+```
+
+注释不能嵌套多个多行注释：`/* /* 嵌套 */ */` 会导致错误。
+
+## 变量声明
+
+### 可变变量
+```go
+var name = "Fig";
+var count = 0;
+count = count + 1;  // 可以重新赋值
+```
+
+### 常量
+```go
+const PI = 3.14159;
+const MAX_SIZE = 100;
+// PI = 3.14;  // 错误：常量不能重新赋值
+```
+
+常量必须在声明时初始化。
+
+### 类型注解（可选）
+```go
+var name: String = "Fig";
+var age: Int = 14;
+const VERSION: Double = 0.4;
+```
+
+类型注解提供额外的类型信息，但解释器会在运行时进行类型检查。
+
+## 标识符命名
+
+### 规则
+- 可以包含字母、数字和下划线
+- 不能以数字开头
+- 区分大小写
+- 支持 Unicode 字符
+
+### 有效示例
+```go
+var count = 0;
+var user_name = "Alice";
+var 计数器 = 0;      // 中文标识符
+var π = 3.14159;    // Unicode 符号
+var _private = true; // 以下划线开头
+```
+
+### 无效示例
+```
+var 123abc = 0;     // 不能以数字开头
+var my-var = 0;     // 不能包含连字符
+```
+
+## 基本字面量
+
+### 数字
+```go
+// 整数
+var a = 42;        // 十进制
+var b = -100;      // 负数
+var c = 0;         // 零
+
+// 浮点数
+var d = 3.14;
+var e = 1.0;
+var f = -0.5;
+var g = 1.23e-10;  // 科学计数法
+```
+
+### 字符串
+```go
+var s1 = "Hello";
+var s2 = "World";
+var s3 = "包含\"引号\"的字符串";  // 转义引号
+var s4 = "第一行\n第二行";        // 转义换行符
+```
+
+多行字符串直接跨行书写：
+```rust
+var message = "这是一个
+多行字符串
+可以包含多行内容";
+```
+
+### 布尔值
+```go
+var yes = true;
+var no = false;
+```
+
+### 空值
+```dart
+var nothing = null;
+```
+
+## 分号使用
+
+所有语句都必须以分号结束：
+
+```go
+var x = 10;         // 正确
+var y = 20          // 错误：缺少分号
+
+func add(a, b) {
+    return a + b;   // return 语句需要分号
+}                   // 函数体右花括号后不需要分号
+```
+
+表达式作为独立语句时也需要分号：
+```go
+1 + 2 * 3;          // 表达式语句需要分号
+io.println("test"); // 函数调用语句需要分号
+```
+
+## 表达式与语句
+
+### 表达式
+表达式会产生一个值（包括 `null`）：
+```go
+1 + 2               // 值为 3
+x * y               // 值为乘积
+funcCall(arg)       // 值为函数返回值
+```
+
+### 语句
+语句执行操作但不产生值：
+```go
+var x = 10;         // 声明语句
+if condition {}     // 条件语句
+return value;       // 返回语句
+```
+
+表达式可以作为语句使用（表达式语句）：
+```go
+1 + 2;              // 计算但丢弃结果
+io.println("hi");   // 函数调用作为语句
+```
+
+## 关键字
+
+Fig 语言的关键字包括：
+
+| 类别     | 关键字                                                      |
+| -------- | ----------------------------------------------------------- |
+| 声明     | `func`, `var`, `const`, `struct`, `interface`, `import`     |
+| 控制流   | `if`, `else`, `while`, `for`, `return`, `break`, `continue` |
+| 错误处理 | `try`, `catch`, `throw`, `Finally`                          |
+| 逻辑运算 | `and`, `or`, `not`                                          |
+| 类型相关 | `is`, `impl`, `new`, `public`                               |
+
+这些关键字不能用作标识符名称。
+
+## 操作符
+
+### 算术运算符
+`+`, `-`, `*`, `/`, `%`, `**`（幂运算）
+
+### 比较运算符
+`==`, `!=`, `<`, `>`, `<=`, `>=`
+
+### 逻辑运算符
+`and`, `or`, `not`, `&&`, `||`, `!`
+
+### 位运算符
+`&`, `|`, `^`, `~`, `<<`, `>>`
+
+### 赋值运算符
+`=`, `:=`, `+=`, `-=`, `*=`, `/=`, `%=`, `^=`
+
+### 其他运算符
+`.`（成员访问）, `?`（三元运算）, `...`（可变参数）, `->`（箭头）, `=>`（双箭头）
+
+## 空白字符
+
+Fig 对空白字符没有特殊要求：
+- 空格和制表符可以互换使用
+- 缩进不影响程序语义
+- 操作符周围的空格是可选的（但建议添加以提高可读性）
+
+## 代码示例
+
+```go
+// 完整的程序示例
+import std.io;
+
+func calculate(a: Int, b: Int) -> Int {
+    var result = a * b;
+    return result + 10;
+}
+
+const x = 5;
+const y = 3;
+var answer = calculate(x, y);
+io.println("结果是：" + answer.toString());
+```

docs/zh_CN/04-数据类型.md

@@ -0,0 +1,156 @@
+# 数据类型
+
+## 类型系统
+
+Fig 语言是动态类型语言，运行时进行类型检查。
+
+## 基本类型
+
+### Null 类型
+表示空值，只有一个值 `null`。
+```dart
+var a = null;
+```
+
+### Int 类型
+64位有符号整数。
+```go
+var x = 42;
+var y = -100;
+```
+
+### Double 类型
+双精度浮点数。
+```go
+var pi = 3.14;
+var speed = 2.998e8;
+```
+
+### String 类型
+字符串。
+```go
+var s1 = "Hello";
+```
+
+### Bool 类型
+布尔值，`true` 或 `false`。
+```go
+var yes = true;
+var no = false;
+```
+
+## 复合类型
+
+### List 类型
+有序集合。
+```go
+var list = [1, 2, 3];
+var mixed = [1, "text", true];
+```
+可以通过 **length()** 方法获取长度，返回Int
+通过 **get()** 方法获取指定下标，不存在的下标返回null
+
+### Map 类型
+键值对集合。
+```go
+var map = {"key": "value", "num": 42};
+```
+
+通过 **get()** 方法获取指定下标，不存在的下标返回 `null`
+
+### Function 类型
+函数。
+```go
+var f = func(x, y) { return x + y; };
+```
+
+## 自定义类型
+
+### 结构体定义
+```rust
+struct Person {
+    name: String;
+    age: Int;
+}
+```
+
+默认字段为私有，如需声明为外部可见的字段，使用 public关键字
+如
+```go
+struct Person {
+    public name: String;
+    public age: Int;
+
+    public func greeting()
+    {
+        io.println("hello!");
+    }
+}
+```
+
+### 创建实例
+使用 `new` 关键字：
+```go
+var p = new Person {name: "Alice", age: 20};
+```
+
+支持三种初始化方式：
+1. 命名参数：`new Person {name: "Alice", age: 20}`
+2. 位置参数：`new Person {"Alice", 20}`
+3. 简写方式：`new Person {name, age}`（使用同名变量）
+
+## 类型操作
+
+### 类型检查
+使用 `is` 运算符：
+```go
+var x = "hello";
+io.println(x is String);  // true
+
+var p = new Person {name: "Alice", age: 20};
+io.println(p is Person);  // true
+```
+
+### 获取类型
+使用 `value.type()` 函数(获取内部类型)：
+```go
+import std.value;
+
+var num = 42;
+var str = "hello";
+var lst = [1, 2, 3];
+
+io.println(value.type(num));  // 获取 num 的类型
+io.println(value.type(str));  // 获取 str 的类型  
+io.println(value.type(lst));  // 获取 lst 的类型
+```
+
+## 类型转换
+
+### 转换函数
+通过 `std.value` 模块：
+```go
+import std.value;
+
+var str = value.string_from(42);      // "42"
+var num = value.int_parse("123");     // 123
+var dbl = value.double_parse("3.14"); // 3.14
+```
+
+## 错误处理
+
+### try-catch 语法
+```rust
+try
+{
+    // 可能抛出异常的代码
+}
+catch(e: ErrorType)
+{
+    // 处理特定类型的错误
+}
+catch(e: AnotherError)
+{
+    // 处理另一种错误
+}
+```

docs/zh_CN/05-函数.md

@@ -0,0 +1,289 @@
+# 函数
+
+## 函数定义
+
+### 基本语法
+```go
+func 函数名(参数列表) -> 返回类型 {
+    函数体
+}
+```
+
+### 示例
+```go
+// 简单函数
+func greet() -> Null {
+    io.println("Hello!");
+}
+
+// 带参数的函数
+func add(a: Int, b: Int) -> Int {
+    return a + b;
+}
+
+// 省略返回类型（默认为 Any）
+func say(message: String) {
+    io.println(message);
+    // 没有 return，返回 null
+}
+```
+
+## 参数
+
+### 必需参数
+```go
+func power(base: Double, exponent: Double) -> Double {
+    return base ** exponent;
+}
+```
+
+### 默认参数
+参数可以指定默认值：
+```go
+func createPerson(name: String, age: Int = 18) -> Null {
+    io.println(name + " is " + age + " years old");
+}
+
+// 调用
+createPerson("Alice");        // 使用默认 age=18
+createPerson("Bob", 25);      // 指定 age=25
+```
+
+### 可变参数
+使用 `...` 表示可变参数，接收一个 List：
+```go
+func sum(numbers...) -> Int {
+    var total = 0;
+    var i = 0;
+    for i = 0; i < numbers.length(); i = i + 1 {
+        total = total + numbers.get(i);
+    }
+    return total;
+}
+
+// 调用
+sum(1, 2, 3);          // 返回 6
+sum(1, 2, 3, 4, 5);    // 返回 15
+```
+
+可变参数不支持类型限制，获取到的总是 List 类型。
+
+## 返回值
+
+### 显式返回
+使用 `return` 语句返回值：
+```go
+func max(a: Int, b: Int) -> Int {
+    if a > b {
+        return a;
+    } else {
+        return b;
+    }
+}
+```
+
+### 无返回值
+函数如果没有 return 语句，返回 null：
+```go
+func log(message: String) -> Null {
+    io.println("[LOG] " + message);
+    // 函数结束，返回 null
+}
+
+func process(data: List) {
+    if data.length() == 0 {
+        return;  // 提前返回 null
+    }
+    // 处理数据...
+    // 函数结束，返回 null
+}
+```
+
+## 函数作为值
+
+### 函数赋值
+函数是一等公民，可以赋值给变量：
+```go
+var addFunc = func(a: Int, b: Int) -> Int {
+    return a + b;
+};
+
+// 调用
+var result = addFunc(3, 4);  // result = 7
+```
+
+### 函数作为参数
+```go
+func applyOperation(x: Int, y: Int, op: Function) -> Int {
+    return op(x, y);
+}
+
+func multiply(a: Int, b: Int) -> Int {
+    return a * b;
+}
+
+// 调用
+var product = applyOperation(3, 4, multiply);  // product = 12
+```
+
+### 函数作为返回值
+```go
+func makeMultiplier(factor: Int) -> Function {
+    return func(x: Int) -> Int {
+        return x * factor;
+    };
+}
+
+// 调用
+var double = makeMultiplier(2);
+var triple = makeMultiplier(3);
+
+io.println(double(5));  // 输出 10
+io.println(triple(5));  // 输出 15
+```
+
+## 匿名函数
+
+### Lambda 表达式
+```go
+// 完整形式
+var square = func(x: Int) {
+    return x * x;
+};
+
+// 简写形式（单表达式）
+var squareShort = func(x: Int) => x * x;
+
+// 调用
+io.println(square(5));      // 输出 25
+io.println(squareShort(5)); // 输出 25
+```
+
+### 立即调用函数表达式
+```go
+var result = func(x: Int, y: Int){
+    return x + y;
+}(3, 4);  // result = 7
+```
+
+## 闭包
+
+### 捕获外部变量
+函数可以捕获其定义作用域中的变量：
+```go
+func makeCounter() -> Function {
+    var count = 0;
+    
+    return func(){
+        count = count + 1;
+        return count;
+    };
+}
+
+// 使用
+var counter = makeCounter();
+io.println(counter());  // 输出 1
+io.println(counter());  // 输出 2
+io.println(counter());  // 输出 3
+```
+
+每个闭包有自己独立的捕获变量：
+```go
+var c1 = makeCounter();
+var c2 = makeCounter();
+
+io.println(c1());  // 输出 1
+io.println(c1());  // 输出 2
+io.println(c2());  // 输出 1（独立的计数）
+```
+
+## 递归函数
+
+函数可以调用自身：
+```go
+func factorial(n: Int) -> Int {
+    if n <= 1 {
+        return 1;
+    }
+    return n * factorial(n - 1);
+}
+
+// 调用
+io.println(factorial(5));  // 输出 120
+```
+
+### 嵌套函数定义
+```go
+func outer(x: Int) -> Int {
+    func inner(y: Int) -> Int {
+        return y * 2;
+    }
+    
+    return inner(x) + 1;
+}
+
+// 调用
+io.println(outer(10));  // 输出 21
+```
+
+## 函数调用
+
+### 普通调用
+```go
+func calculate(a: Int, b: Int, c: Int) -> Int {
+    return a + b * c;
+}
+
+// 位置参数调用
+var result = calculate(1, 2, 3);  // 1 + 2*3 = 7
+```
+
+### 方法调用语法
+对象的方法调用：
+```go
+var list = [1, 2, 3];
+var length = list.length();  // 方法调用
+```
+
+## 函数示例
+
+### 实用函数组合
+```go
+import std.io;
+
+// 高阶函数示例
+func compose(f: Function, g: Function) -> Function {
+    return func(x: Any) -> Any {
+        return f(g(x));
+    };
+}
+
+// 使用
+func addOne(x: Int) -> Int {
+    return x + 1;
+}
+
+func double(x: Int) -> Int {
+    return x * 2;
+}
+
+var addThenDouble = compose(double, addOne);
+io.println(addThenDouble(5));  // (5+1)*2 = 12
+```
+
+### 回调函数模式
+```go
+func processData(data: List, callback: Function) -> Null {
+    var i = 0;
+    for i = 0; i < data.length(); i = i + 1 {
+        var result = callback(data.get(i));
+        io.println("处理结果: " + result);
+    }
+}
+
+// 使用
+var numbers = [1, 2, 3, 4, 5];
+processData(numbers, func(x){
+    return x * x;
+});
+```

docs/zh_CN/06-面对对象.md

@@ -0,0 +1,126 @@
+# 面对对象
+
+> Fig中只有结构体(`struct`) 遵循go圣经 组合由于继承 (struct组合尚未推出)
+
+## 结构体定义
+完整语法：
+```cpp
+struct Point
+{
+    public x: Int; // 公开字段
+    public y: Int; // 公开字段
+}
+
+struct Person
+{
+    name: String; // 私有字段，无法被外部访问
+    age: Int; // 私有字段，无法被外部访问
+    sex: String = "Airplane"; // 私有字段，无法被外部访问
+
+    public func getName() -> String // 公开类函数
+    {
+        return name;
+    }
+}
+```
+
+## 结构体初始化
+语法：
+```go
+
+// 位置参数构造
+var person := new Person{
+    "Fig", // name
+    1,     // age
+    "Language" // sex
+};
+```
+
+```go
+// 命名参数构造模式，可以无序
+var person := new Person{
+    name: "Fig",
+    age: 1,
+    sex: "Language"
+};
+```
+
+```go
+// 语法糖：同名变量构造
+const name := "Fig";
+const age := 1;
+const sex := "Language";
+
+var person := new Person{sex, name, age}; // 可以无序，自动匹配
+```
+
+请注意，同名变量构造(shorthand)模式请规范使用：
+ 
+示例：定义
+```cpp
+struct Point
+{
+    public x;
+    public y;
+}
+```
+使用：
+```go
+var a := Point{1,2};
+io.println(a.x, a.y); // 1 2
+
+var x := 7;
+var y := 6;
+var b := Point{y, x};
+io.println(b.x, b.y); // 7 6
+// ??
+```
+
+使用该模式最好有序构造，如果你清楚你在做什么，完全可以利用它
+
+## 结构体运算符重载
+
+**目前不支持**
+
+## 接口与实现
+`interface` 与 `implement`
+
+### 定义接口
+```go
+interface Printable
+{
+    toString() -> String;
+    getName() -> String
+    {
+        return "Printable";
+    }
+}
+```
+
+使用 `interface` + 名字 {内容}定义结构体
+方法签名为 `method() -> type`，其中必须提供返回类型，这是约定。
+提供默认方法将在子类实现为实现情况下自动替补
+
+### 实现
+```rust
+struct Person
+{
+    name: String;
+    age: Int;
+}
+
+impl Printable for Person
+{
+    toString()
+    {
+        return name + ":" + age;
+    }
+    getName()
+    {
+        return "Person";
+    }
+}
+```
+
+实现时不需要也不允许提供返回类型，必须与`interface`约定一致
+内部通过动态派发 vtable实现

fig-vscode/package.json

@@ -2,7 +2,7 @@
   "name": "fig-vscode",
   "displayName": "Fig Language",
   "description": "VSCode extension for Fig language with syntax highlighting",
-  "version": "0.0.2",
+  "version": "0.4.3",
   "publisher": "PuqiAR",
   "engines": {
     "vscode": "^1.90.0"

fig-vscode/syntaxes/fig.tmLanguage.json

@@ -57,7 +57,7 @@
       "patterns": [
         {
           "name": "keyword.control.fig",
-          "match": "\\b(and|or|not|import|func|var|const|final|while|for|if|else|struct|interface|impl|public|return|break|continue|try|catch|throw)\\b"
+          "match": "\\b(and|or|not|import|func|var|const|final|while|for|if|else|new|struct|interface|impl|public|return|break|continue|try|catch|throw|is|as)\\b"
         },
         { "name": "constant.language.fig", "match": "\\b(true|false|null)\\b" }
       ]
@@ -78,7 +78,7 @@
         },
         {
           "name": "keyword.operator.comparison.fig",
-          "match": "(==|!=|<=|>=|<|>|is)"
+          "match": "(==|!=|<=|>=|<|>)"
         },
         {
           "name": "punctuation.separator.fig",

src/Ast/Expressions/FunctionCall.hpp

@@ -2,7 +2,7 @@
 #pragma once
 
 #include <Ast/astBase.hpp>
-#include <Value/value.hpp>
+#include <Evaluator/Value/value.hpp>
 
 namespace Fig::Ast
 {

src/Ast/Expressions/ValueExpr.hpp

@@ -2,7 +2,7 @@
 
 #include <Ast/astBase.hpp>
 
-#include <Value/value.hpp>
+#include <Evaluator/Value/value.hpp>
 
 namespace Fig::Ast
 {

src/Ast/Statements/FunctionDefSt.hpp

@@ -3,7 +3,7 @@
 #include <Ast/astBase.hpp>
 #include <Ast/functionParameters.hpp>
 
-#include <Value/value.hpp>
+#include <Evaluator/Value/value.hpp>
 
 namespace Fig::Ast
 {
@@ -23,14 +23,14 @@ namespace Fig::Ast
         FString name;
         FunctionParameters paras;
         bool isPublic;
-        FString retType;
+        Expression retType; 
         BlockStatement body;
-        FunctionDefSt() :
-            retType(ValueType::Null.name)
+
+        FunctionDefSt()
         {
             type = AstType::FunctionDefSt;
         }
-        FunctionDefSt(FString _name, FunctionParameters _paras, bool _isPublic, FString _retType, BlockStatement _body)
+        FunctionDefSt(FString _name, FunctionParameters _paras, bool _isPublic, Expression _retType, BlockStatement _body)
         {
             type = AstType::FunctionDefSt;
 

src/Ast/Statements/ImportSt.hpp

@@ -6,18 +6,26 @@
 
 namespace Fig::Ast
 {
+    /*
+    import std.io as stdio; // io --> stdio;
+    import std.io {print, println};
+    */
+
     class ImportSt final : public StatementAst
     {
     public:
         std::vector<FString> path;
+        std::vector<FString> names;
+
+        FString rename;
         
         ImportSt()
         {
             type = AstType::ImportSt;
         }
 
-        ImportSt(std::vector<FString> _path) :
-            path(std::move(_path)) 
+        ImportSt(std::vector<FString> _path, std::vector<FString> _names, const FString &_rename) :
+            path(std::move(_path)), names(std::move(_names)), rename(_rename)
         {
             type = AstType::ImportSt;
         }

src/Ast/Statements/InterfaceDefSt.hpp

@@ -25,7 +25,7 @@ namespace Fig::Ast
     {
         FString name;
         FunctionParameters paras;
-        FString returnType;
+        Expression returnType;
 
         BlockStatement defaultBody = nullptr; // nullptr is non-default func
 

src/Ast/Statements/StructDefSt.hpp

@@ -12,12 +12,12 @@ namespace Fig::Ast
     {
         AccessModifier am;
         FString fieldName;
-        FString tiName;
+        Expression declaredType; 
         Expression defaultValueExpr;
 
         StructDefField() {}
-        StructDefField(AccessModifier _am, FString _fieldName, FString _tiName, Expression _defaultValueExpr) :
-            am(std::move(_am)), fieldName(std::move(_fieldName)), tiName(std::move(_tiName)), defaultValueExpr(std::move(_defaultValueExpr))
+        StructDefField(AccessModifier _am, FString _fieldName,  Expression _declaredType, Expression _defaultValueExpr) :
+            am(std::move(_am)), fieldName(std::move(_fieldName)), declaredType(std::move(_declaredType)), defaultValueExpr(std::move(_defaultValueExpr))
         {
         }
     };

src/Ast/Statements/VarDef.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Ast/astBase.hpp>
-#include <Value/Type.hpp>
+#include <Evaluator/Value/Type.hpp>
 
 namespace Fig::Ast
 {
@@ -11,22 +11,28 @@ namespace Fig::Ast
         bool isPublic;
         bool isConst;
         FString name;
-        FString typeName;
+        // FString typeName;
+        Expression declaredType;
         Expression expr;
 
-        VarDefAst() :
-            typeName(ValueType::Any.name)
+        bool followupType;
+
+        VarDefAst()
         {
             type = AstType::VarDefSt;
+            declaredType = nullptr;
+            expr = nullptr;
+            followupType = false;
         }
-        VarDefAst(bool _isPublic, bool _isConst, FString _name, FString _info, Expression _expr) :
-            typeName(std::move(_info))
+        VarDefAst(bool _isPublic, bool _isConst, FString _name, Expression _declaredType, Expression _expr, bool _followupType)
         {
             type = AstType::VarDefSt;
             isPublic = _isPublic;
             isConst = _isConst;
             name = std::move(_name);
+            declaredType = std::move(_declaredType);
             expr = std::move(_expr);
+            followupType = _followupType;
         }
     };
 

src/Ast/astBase.hpp

@@ -26,15 +26,16 @@ namespace Fig::Ast
         TernaryExpr,
 
         /* Postfix */
-        MemberExpr, // a.b
-        IndexExpr,  // a[b]
+        MemberExpr,   // a.b
+        IndexExpr,    // a[b]
         FunctionCall, // a()
 
         /* Literals */
         ListExpr,  // [1, "2", 3
         TupleExpr, // (1, 2, 3)
         MapExpr,   // {a: 1}
-        InitExpr,  // struct{"123", 456}
+
+        InitExpr, // struct{"123", 456}
         FunctionLiteralExpr,
 
         /* Statement */
@@ -100,6 +101,8 @@ namespace Fig::Ast
     struct AstAddressInfo
     {
         size_t line, column;
+        std::shared_ptr<FString> sourcePath;
+        std::shared_ptr<std::vector<FString>> sourceLines;
     };
 
     class _AstBase
@@ -117,30 +120,20 @@ namespace Fig::Ast
 
         _AstBase() {}
 
-        void setAAI(AstAddressInfo _aai)
-        {
-            aai = std::move(_aai);
-        }
+        void setAAI(AstAddressInfo _aai) { aai = std::move(_aai); }
 
         virtual FString typeName()
         {
-            return FString::fromStringView(
-                FStringView::fromBasicStringView(magic_enum::enum_name(type)));
+            return FString::fromStringView(FStringView::fromBasicStringView(magic_enum::enum_name(type)));
         }
         virtual FString toString()
         {
             return FString(std::format("<Base Ast '{}' at {}:{}>", typeName().toBasicString(), aai.line, aai.column));
         }
 
-        AstAddressInfo getAAI()
-        {
-            return aai;
-        }
+        AstAddressInfo getAAI() { return aai; }
 
-        AstType getType()
-        {
-            return type;
-        }
+        AstType getType() { return type; }
     };
 
     class StatementAst : public _AstBase
@@ -148,10 +141,7 @@ namespace Fig::Ast
     public:
         using _AstBase::_AstBase;
         using _AstBase::operator=;
-        StatementAst()
-        {
-            type = AstType::StatementBase;
-        }
+        StatementAst() { type = AstType::StatementBase; }
 
         virtual FString toString() override
         {
@@ -162,10 +152,7 @@ namespace Fig::Ast
     class EofStmt final : public StatementAst
     {
     public:
-        EofStmt()
-        {
-            type = AstType::StatementBase;
-        }
+        EofStmt() { type = AstType::StatementBase; }
 
         virtual FString toString() override
         {
@@ -178,10 +165,7 @@ namespace Fig::Ast
     public:
         using _AstBase::_AstBase;
         using _AstBase::operator=;
-        ExpressionAst()
-        {
-            type = AstType::ExpressionBase;
-        }
+        ExpressionAst() { type = AstType::ExpressionBase; }
 
         virtual FString toString() override
         {
@@ -215,6 +199,9 @@ namespace Fig::Ast
         GreaterEqual, // >=
         Is,           // a is b
 
+        // 转换
+        As, // 3.14 as Int
+
         // 三目
         TernaryCond,
 
@@ -240,41 +227,24 @@ namespace Fig::Ast
     static const std::unordered_set<Operator> unaryOps{
         Operator::Not,      // !
         Operator::Subtract, // -
-        Operator::BitNot, // ~
+        Operator::BitNot,   // ~
 
         Operator::BitAnd, // reference operator &
     };
     static const std::unordered_set<Operator> binaryOps{
-        Operator::Add,
-        Operator::Subtract,
-        Operator::Multiply,
-        Operator::Divide,
-        Operator::Modulo,
-        Operator::Power,
-        Operator::And,
-        Operator::Or,
+        Operator::Add,         Operator::Subtract,     Operator::Multiply,    Operator::Divide,
+        Operator::Modulo,      Operator::Power,        Operator::And,         Operator::Or,
 
-        Operator::Equal,
-        Operator::NotEqual,
-        Operator::Less,
-        Operator::LessEqual,
-        Operator::Greater,
-        Operator::GreaterEqual,
-        Operator::Is,
+        Operator::Equal,       Operator::NotEqual,     Operator::Less,        Operator::LessEqual,
+        Operator::Greater,     Operator::GreaterEqual, Operator::Is,
 
-        Operator::BitAnd,
-        Operator::BitOr,
-        Operator::BitXor,
-        Operator::BitNot,
-        Operator::ShiftLeft,
-        Operator::ShiftRight,
+        Operator::As,
 
-        Operator::Assign,
-        Operator::PlusAssign,
-        Operator::MinusAssign,
-        Operator::AsteriskAssign,
-        Operator::SlashAssign,
-        Operator::CaretAssign
+        Operator::BitAnd,      Operator::BitOr,        Operator::BitXor,      Operator::BitNot,
+        Operator::ShiftLeft,   Operator::ShiftRight,
+
+        Operator::Assign,      Operator::PlusAssign,   Operator::MinusAssign, Operator::AsteriskAssign,
+        Operator::SlashAssign, Operator::CaretAssign
 
         // Operator::Walrus,
         // Operator::Dot
@@ -306,6 +276,9 @@ namespace Fig::Ast
         {TokenType::GreaterEqual, Operator::GreaterEqual},
         {TokenType::Is, Operator::Is},
 
+        // 转换
+        {TokenType::As, Operator::As},
+
         // 三目
         {TokenType::Question, Operator::TernaryCond},
 
@@ -350,19 +323,9 @@ namespace Fig::Ast
     {
     public:
         std::vector<Statement> stmts;
-        BlockStatementAst()
-        {
-            type = AstType::BlockStatement;
-        }
-        BlockStatementAst(std::vector<Statement> _stmts) :
-            stmts(std::move(_stmts))
-        {
-            type = AstType::BlockStatement;
-        }
-        virtual FString typeName() override
-        {
-            return FString(u8"BlockStatement");
-        }
+        BlockStatementAst() { type = AstType::BlockStatement; }
+        BlockStatementAst(std::vector<Statement> _stmts) : stmts(std::move(_stmts)) { type = AstType::BlockStatement; }
+        virtual FString typeName() override { return FString(u8"BlockStatement"); }
         virtual FString toString() override
         {
             return FString(std::format("<StmtAst '{}' at {}:{}>", typeName().toBasicString(), aai.line, aai.column));

src/Ast/functionParameters.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Ast/astBase.hpp>
-#include <Value/Type.hpp>
+#include <Evaluator/Value/Type.hpp>
 #include <Core/fig_string.hpp>
 
 #include <format>
@@ -17,8 +17,10 @@ namespace Fig::Ast
                 func test2(dp1 = 10, dp2:String = "default parameter 2")
         */
 
-        using PosParasType = std::vector<std::pair<FString, FString>>;
-        using DefParasType = std::vector<std::pair<FString, std::pair<FString, Expression>>>;
+        using PosParasType = std::vector<std::pair<FString, Expression>>;
+        //                                          name       type exp
+        using DefParasType = std::vector<std::pair<FString, std::pair<Expression, Expression>>>;
+        //                                          name                type exp     default value
 
         PosParasType posParas;
         DefParasType defParas; // default parameters
@@ -56,28 +58,28 @@ namespace Fig::Ast
             {
                 return FString(variadicPara + u8"...");
             }
-            static const auto posParasToString = [this]() {
+            const auto posParasToString = [this]() {
                 FString out;
                 for (auto &p : posParas)
                 {
                     out += p.first;
-                    if (!p.second.empty())
+                    if (p.second != nullptr)
                     {
-                        out += FString(u8":" + p.second);
+                        out += FString(u8":" + p.second->toString());
                     }
                     out += u8",";
                 }
                 out.pop_back();
                 return out;
             };
-            static const auto defParasToString = [this]() {
+            const auto defParasToString = [this]() {
                 FString out;
                 for (auto &p : defParas)
                 {
                     out += p.first;
-                    if (!p.second.first.empty())
+                    if (p.second.first != nullptr)
                     {
-                        out += FString(u8":" + p.second.first);
+                        out += FString(u8":" + p.second.first->toString());
                     }
                     if (p.second.second != nullptr)
                     {

src/Bytecode/Bytecode.hpp

@@ -1,125 +0,0 @@
-#pragma once
-
-/*
-
-从树遍历到虚拟机!
-
-*/
-
-#include "Core/fig_string.hpp"
-#include "Utils/magic_enum/magic_enum.hpp"
-#include <cstdint>
-#include <format>
-#include <string_view>
-
-namespace Fig
-{
-    using OpCodeType = uint8_t;
-    enum class Bytecode : OpCodeType
-    {
-        HALT = 0x01, // 程序终止，后跟 8 位退出码
-
-        POP = 0x10,
-
-        LOAD_NULL = 0x20,
-        LOAD_TRUE = 0x21,
-        LOAD_FALSE = 0x22,
-        LOAD_CON8 = 0x23,  // 跟 8  位索引 (0     - 255)
-        LOAD_CON16 = 0x24, // 跟 16 位索引 (255   - 65535)
-        LOAD_CON32 = 0x25, // 跟 32 位索引 (65536 - 2^32-1)
-
-        ADD = 0x30, // +
-        SUB = 0x31, // -
-        MUL = 0x32, // *
-        DIV = 0x33, // /
-        MOD = 0x34, // %
-
-        AND = 0x40, // &
-        OR = 0x41,  // |
-        XOR = 0x42, // ~
-        NOT = 0x43, // ! (not)
-
-        EQ = 0x50,   // ==
-        GT = 0x51,   // >
-        GTEQ = 0x52, // >=
-        LT = 0x53,   // <
-        LTEQ = 0x54, // <=
-
-        JUMP16 = 0x60, // 跟 16 位索引 无条件
-        JUMP32 = 0x61, // 跟 32 位索引 无条件
-
-        JUMP16_IF_TRUE = 0x62, // 跟 16 位索引 栈顶为真跳转
-        JUMP32_IF_TRUE = 0x63, // 跟 32 位索引 栈顶为真跳转
-
-        JUMP16_IF_FALSE = 0x64, // 跟 16 位索引 栈顶为假跳转
-        JUMP32_IF_FALSE = 0x65, // 跟 32 位索引 栈顶为假跳转
-
-        LOAD_LOCAL16 = 0x70, // 后跟 16 位索引
-        LOAD_LOCAL32 = 0x71, // 后跟 32 位索引
-    };
-
-    inline FString bytecode2string(Bytecode code)
-    {
-        const std::string_view &name = magic_enum::enum_name(code);
-        return FString(FStringView(name));
-    }
-
-    inline FString reverseCompile(const std::vector<uint8_t> &src)
-    {
-        assert(src.size() >= 1);
-
-        FString result;
-
-        using enum Bytecode;
-        for (size_t i = 0; i < src.size();)
-        {
-            Bytecode code = Bytecode(src[i]);
-            switch (code)
-            {
-                case HALT: {
-                    uint8_t quitCode = src[++i];
-                    result += FString(std::format("HALT {}", static_cast<uint8_t>(quitCode))) + u8"\n";
-                    break;
-                }
-                case LOAD_CON8: {
-                    uint8_t id = src[++i];
-                    result += FString(std::format("LOAD_CON8 {}", static_cast<uint8_t>(id))) + u8"\n";
-                    break;
-                }
-                case LOAD_CON16:
-                case JUMP16:
-                case JUMP16_IF_TRUE:
-                case JUMP16_IF_FALSE:
-                case LOAD_LOCAL16: {
-                    uint8_t high = src[++i];
-                    uint8_t low = src[++i];
-                    int32_t id = (high << 8) | low;
-                    result += FString(std::format("{} {}", bytecode2string(code).toBasicString(), id))
-                              + u8"\n";
-                    break;
-                }
-
-                case LOAD_CON32:
-                case JUMP32:
-                case JUMP32_IF_TRUE:
-                case JUMP32_IF_FALSE:
-                case LOAD_LOCAL32: {
-                    uint32_t b0 = static_cast<uint32_t>(src[++i]);
-                    uint32_t b1 = static_cast<uint32_t>(src[++i]);
-                    uint32_t b2 = static_cast<uint32_t>(src[++i]);
-                    uint32_t b3 = static_cast<uint32_t>(src[++i]);
-
-                    uint32_t id = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
-                    result += FString(std::format("{} {}", bytecode2string(code).toBasicString(), id))
-                              + u8"\n";
-                    break;
-                }
-                default: {
-                    result += bytecode2string(code) + u8"\n";
-                }
-            }
-            ++i;
-        }
-        return result;
-    }
-}; // namespace Fig

src/Bytecode/CallFrame.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <Bytecode/CompiledFunction.hpp>
+#include <Bytecode/Instruction.hpp>
+#include <Bytecode/Chunk.hpp>
+
+namespace Fig
+{
+    struct CallFrame
+    {
+        uint64_t ip;         // 函数第一个指令 index
+        uint64_t base;       // 第一个参数在栈中位置偏移量
+
+        CompiledFunction fn; // 编译过的函数体
+    };
+
+};

src/Bytecode/Chunk.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Core/fig_string.hpp>
+#include <Bytecode/Instruction.hpp>
+#include <Evaluator/Value/value.hpp>
+
+#include <vector>
+
+namespace Fig
+{
+    struct ChunkAddressInfo
+    {
+        FString sourcePath;
+        std::vector<FString> sourceLines;
+    };
+
+    struct Chunk
+    {
+        Instructions ins; // vector<Instruction>
+        std::vector<Object> constants; // 常量池
+
+        std::vector<InstructionAddressInfo> instructions_addr; // 下标和ins对齐，表示每个Instruction对应的地址
+        ChunkAddressInfo addr; // 代码块独立Addr
+    };
+};

src/Bytecode/CompileError.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <Error/error.hpp>
+
+namespace Fig
+{
+    class CompileError : public AddressableError
+    {
+        using AddressableError::AddressableError;
+
+        virtual FString toString() const override
+        {
+            std::string msg = std::format("[CompileError] {} in [{}] {}",
+                                          this->message.toBasicString(),
+                                          this->src_loc.file_name(),
+                                          this->src_loc.function_name());
+            return FString(msg);
+        }
+
+        virtual FString getErrorType() const override { return FString(u8"CompileError"); }
+    };
+};

src/Bytecode/CompiledFunction.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <Bytecode/Instruction.hpp>
+#include <Bytecode/Chunk.hpp>
+
+namespace Fig
+{
+    struct CompiledFunction
+    {
+
+        Chunk chunk; // 函数代码块
+
+        FString name;  // 函数名
+        uint64_t posArgCount; // 位置参数数量
+        uint64_t defArgCount; // 默认参数数量
+        bool variadicPara;    // 可变参数（是：最后为可变，否：不可变）
+
+        uint64_t localCount;  // 局部变量数量(不包括参数)
+        uint64_t slotCount; // = 总参数数量 + 局部变量数量
+    };
+};

src/Bytecode/Instruction.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <cstdint>
+#include <cassert>
+#include <vector>
+
+namespace Fig
+{
+    using u8 = uint8_t;
+    enum class OpCode : u8
+    {
+        HALT = 0, // 程序结束
+        RETURN,
+
+        LOAD_LOCAL,
+        LOAD_CONST,
+
+        STORE_LOCAL,
+
+        LT,
+        LTET,
+        GT,
+        GTET,
+        ADD,
+        SUB,
+        MUL,
+        DIV,
+
+        JUMP,          // + 64 offset (int64_t)
+        JUMP_IF_FALSE, // + 64 offset (int64_t)
+
+        CALL,
+    };
+
+    static constexpr int MAX_LOCAL_COUNT = UINT64_MAX;
+    static constexpr int MAX_CONSTANT_COUNT = UINT64_MAX;
+    static constexpr int MAX_FUNCTION_ARG_COUNT = UINT64_MAX;
+
+    inline OpCode getLastOpCode()
+    {
+        return OpCode::RETURN;
+    }
+
+    struct InstructionAddressInfo
+    {
+        size_t line, column;
+    };
+
+    using ProgramCounter = uint64_t;
+    using InstructionPoint = uint64_t;
+
+    class Instruction
+    {
+    public:
+        OpCode code;
+
+        int64_t operand;
+
+        Instruction(OpCode _code) : code(_code) {}
+
+        Instruction(OpCode _code, int64_t _operand)
+        {
+            code = _code;
+            operand = _operand;
+        }
+    };
+
+    using Instructions = std::vector<Instruction>;
+}; // namespace Fig

src/Bytecode/vm_test_main.cpp

@@ -0,0 +1,107 @@
+#include <Bytecode/Chunk.hpp>
+#include <Bytecode/Instruction.hpp>
+#include <Bytecode/CompiledFunction.hpp>
+#include <VirtualMachine/VirtualMachine.hpp>
+
+#include <chrono>
+#include <iostream>
+
+using namespace Fig;
+
+int main()
+{
+    /*
+        func fib(x)
+        {
+            if x <= 1
+            {
+                return x;
+            }
+            return fib(x - 1) + fib(x - 2);
+        }
+    */
+
+    // ---------------- fib ----------------
+
+    Instructions fib_ins{
+        /*  0 */ {OpCode::LOAD_LOCAL, 0},   // x
+        /*  1 */ {OpCode::LOAD_CONST, 0},   // 1
+        /*  2 */ {OpCode::LTET},               // x <= 1
+        /*  3 */ {OpCode::JUMP_IF_FALSE, 2}, // false -> jump to 6
+
+        /*  4 */ {OpCode::LOAD_LOCAL, 0}, // return x
+        /*  5 */ {OpCode::RETURN},
+
+        /*  6 */ {OpCode::LOAD_LOCAL, 0}, // x
+        /*  7 */ {OpCode::LOAD_CONST, 0}, // 1
+        /*  8 */ {OpCode::SUB},              // x - 1
+        /*  9 */ {OpCode::LOAD_CONST, 2}, // fib
+        /* 10 */ {OpCode::CALL, 1},       // fib(x-1)
+
+        /* 11 */ {OpCode::LOAD_LOCAL, 0}, // x
+        /* 12 */ {OpCode::LOAD_CONST, 1}, // 2
+        /* 13 */ {OpCode::SUB},              // x - 2
+        /* 14 */ {OpCode::LOAD_CONST, 2}, // fib
+        /* 15 */ {OpCode::CALL, 1},       // fib(x-2)
+
+        /* 16 */ {OpCode::ADD},
+        /* 17 */ {OpCode::RETURN},
+    };
+
+    std::vector<Object> fib_consts{
+        Object((int64_t) 1), // 0
+        Object((int64_t) 2), // 1
+        Object(),            // 2 fib (回填)
+    };
+
+    CompiledFunction fib_fn{
+        {},
+        u8"fib",
+        1, // posArgCount
+        0,
+        false,
+        0, // localCount
+        1  // slotCount = 参数 x
+    };
+
+    // fib 自引用
+    fib_consts[2] = Object(Function(&fib_fn));
+
+    Chunk fib_chunk{fib_ins, fib_consts, {}, ChunkAddressInfo{}};
+
+    fib_fn.chunk = fib_chunk;
+
+    // ---------------- main ----------------
+
+    Instructions main_ins{
+        {OpCode::LOAD_CONST, 0}, // 30
+        {OpCode::LOAD_CONST, 1}, // fib
+        {OpCode::CALL, 1},
+        {OpCode::RETURN},
+    };
+
+    std::vector<Object> main_consts{
+        Object((int64_t)251), // 0
+        Object(Function(&fib_fn)),       // 1
+    };
+
+    Chunk main_chunk{main_ins, main_consts, {}, ChunkAddressInfo{}};
+
+    CompiledFunction main_fn{main_chunk, u8"main", 0, 0, false, 0, 0};
+
+    CallFrame entry{.ip = 0, .base = 0, .fn = main_fn};
+
+    VirtualMachine vm(entry);
+
+    using Clock = std::chrono::high_resolution_clock;
+
+    auto start = Clock::now();
+    Object result = vm.Execute();
+    auto end = Clock::now();
+
+    auto duration_secs = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();
+    auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+
+    std::cout << result.toString().toBasicString() << "\n";
+    std::cout << "cost: " << duration_secs << "s. " << duration_ms << "ms" << "\n";
+}

src/Compiler/Compiler.cpp

@@ -1,21 +0,0 @@
-#include <Ast/astBase.hpp>
-#include <Compiler/Compiler.hpp>
-#include <memory>
-
-namespace Fig
-{
-    void Compiler::compile(Ast::Statement stmt)
-    {
-        using enum Ast::AstType;
-        using namespace Ast;
-        Ast::AstType type = stmt->getType();
-
-        switch (type)
-        {
-            case VarDefSt: {
-                auto vd = std::static_pointer_cast<VarDefAst>(stmt);
-                const FString name = vd->name;
-            }
-        }
-    }
-}; // namespace Fig

src/Compiler/Compiler.hpp

@@ -1,32 +0,0 @@
-#pragma once
-
-#include "Ast/astBase.hpp"
-#include <Ast/ast.hpp>
-#include <Bytecode/Bytecode.hpp>
-#include <VMValue/VMValue.hpp>
-
-#include <vector>
-
-namespace Fig
-{
-    class Compiler
-    {
-    private:
-        std::vector<Ast::Statement> source;
-        std::vector<OpCodeType> output; // std::vector<uint8_t>
-
-        std::vector<Value> constants;   
-    public:
-        std::vector<OpCodeType> getOutput() const { return output; }
-        std::vector<Value> getConstantPool() const { return constants; }
-
-        Compiler() {}
-        Compiler(std::vector<Ast::Statement> _source) : source(std::move(_source)) {}
-
-        void compile_expr(Ast::Expression);
-
-        void compile(Ast::Statement);
-
-        void CompileAll();
-    };
-}; // namespace Fig

src/Core/core.hpp

@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <string_view>
 
-#define __FCORE_VERSION "0.3.7-alpha"
+#define __FCORE_VERSION "0.4.3-alpha"
 
 #if defined(_WIN32)
     #define __FCORE_PLATFORM "Windows"

src/Core/executablePath.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <filesystem>
+
+#ifdef _WIN32
+    #include <libloaderapi.h>
+#endif
+
+namespace Fig
+{
+    inline std::filesystem::path getExecutablePath()
+    {
+#ifdef _WIN32
+        wchar_t buffer[MAX_PATH];
+        GetModuleFileNameW(nullptr, buffer, MAX_PATH);
+        return std::filesystem::path(buffer);
+#else
+        return std::filesystem::canonical("/proc/self/exe");
+#endif
+    }
+}; // namespace Fig

src/Core/fig_string.hpp

@@ -38,6 +38,7 @@ namespace Fig
     {
     public:
         using std::u8string::u8string;
+        using std::u8string::operator=;
 
         FString operator+(const FString &x)
         {

src/Core/runtimeTime.cpp

@@ -0,0 +1,18 @@
+#include <Core/runtimeTime.hpp>
+
+#include <cassert>
+
+namespace Fig::Time
+{
+    Clock::time_point start_time;
+    void init()
+    {
+        static bool flag = false;
+        if (flag)
+        {
+            assert(false);
+        }
+        start_time = Clock::now();
+        flag = true;
+    }
+};

src/Core/runtimeTime.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <chrono>
+
+namespace Fig::Time
+{
+    using Clock = std::chrono::steady_clock;
+    extern Clock::time_point start_time; // since process start
+    void init();
+};

src/Core/utf8_iterator.hpp

@@ -58,7 +58,7 @@ namespace Fig
             switch (len)
             {
                 case 1:
-                    code_point = char_data_[0];
+                    code_point = static_cast<char32_t>(char_data_[0]);
                     break;
                 case 2:
                     code_point = ((char_data_[0] & 0x1F) << 6) | (char_data_[1] & 0x3F);

src/Error/error.hpp

@@ -6,6 +6,7 @@
 #include <format>
 #include <source_location>
 #include <string>
+#include <vector>
 
 namespace Fig
 {
@@ -16,8 +17,10 @@ namespace Fig
         explicit AddressableError(FString _msg,
                                   size_t _line,
                                   size_t _column,
+                                  FString _sourcePath,
+                                  std::vector<FString> _sourceLines,
                                   std::source_location loc = std::source_location::current()) :
-            src_loc(loc), line(_line), column(_column)
+            src_loc(loc), line(_line), column(_column), sourcePath(std::move(_sourcePath)), sourceLines(std::move(_sourceLines))
         {
             message = _msg;
         }
@@ -33,9 +36,11 @@ namespace Fig
         }
         std::source_location src_loc;
 
-        size_t getLine() const { return line; }
-        size_t getColumn() const { return column; }
+        virtual size_t getLine() const { return line; }
+        virtual size_t getColumn() const { return column; }
         FString getMessage() const { return message; }
+        FString getSourcePath() const { return sourcePath; }
+        std::vector<FString> getSourceLines() const { return sourceLines; }
 
         virtual FString getErrorType() const
         {
@@ -45,6 +50,9 @@ namespace Fig
     protected:
         size_t line, column;
         FString message;
+
+        FString sourcePath;
+        std::vector<FString> sourceLines;
     };
 
     class UnaddressableError : public std::exception
@@ -84,14 +92,6 @@ namespace Fig
     public:
         using AddressableError::AddressableError;
 
-        explicit SyntaxError(FString _msg,
-                             size_t _line,
-                             size_t _column,
-                             std::source_location loc = std::source_location::current()) :
-            AddressableError(_msg, _line, _column, loc)
-        {
-        }
-
         virtual FString toString() const override
         {
             std::string msg = std::format("[SyntaxError] {} in [{}] {}", this->message.toBasicString(), this->src_loc.file_name(), this->src_loc.function_name());

src/Error/errorLog.hpp

@@ -97,9 +97,20 @@ namespace Fig
             std::print("{}{}{}", colorCode, msg, TerminalColors::Reset);
         }
 
-
-        inline void logAddressableError(const AddressableError &err, FString fileName, std::vector<FString> sourceLines)
+        inline void logFigErrorInterface(const FString &errorClass, const FString &errorMessage)
         {
+            namespace TC = TerminalColors;
+            coloredPrint(TC::LightWhite, "Uncaught Fig exception:\n");
+            coloredPrint(TC::LightRed, "✖  ");
+            coloredPrint(TC::Red, errorClass.toBasicString() + ": ");
+            coloredPrint(TC::Red, errorMessage.toBasicString() + "\n");
+        }
+
+        inline void logAddressableError(const AddressableError &err)
+        {
+            const FString &fileName = err.getSourcePath();
+            const std::vector<FString> &sourceLines = err.getSourceLines();
+
             std::print("\n");
             namespace TC = TerminalColors;
             coloredPrint(TC::LightWhite, "An error occurred! ");
@@ -107,21 +118,30 @@ namespace Fig
             coloredPrint(TC::LightRed, "✖  ");
             coloredPrint(TC::LightRed, std::format("{}: {}\n", err.getErrorType().toBasicString(), FString(err.getMessage()).toBasicString()));
             coloredPrint(TC::White, std::format("    at {}:{} in file '{}'\n", err.getLine(), err.getColumn(), fileName.toBasicString()));
-            FString lineContent = ((int64_t(err.getLine()) - int64_t(1)) >= 0 ? sourceLines[err.getLine() - 1] : u8"<No Source>");
-            coloredPrint(TC::LightBlue, std::format("    {}\n", lineContent.toBasicString()));
+
+            FString lineContent;
             FString pointerLine;
-            for (size_t i = 1; i < err.getColumn(); ++i)
+
+            if (fileName != u8"<stdin>")
             {
-                if (lineContent[i - 1] == U'\t')
+                lineContent = ((int64_t(err.getLine()) - int64_t(1)) >= 0 ? sourceLines[err.getLine() - 1] : u8"<No Source>");
+                for (size_t i = 1; i < err.getColumn(); ++i)
                 {
-                    pointerLine += U'\t';
-                }
-                else
-                {
-                    pointerLine += U' ';
+                    if (lineContent[i - 1] == U'\t') { pointerLine += U'\t'; }
+                    else
+                    {
+                        pointerLine += U' ';
+                    }
                 }
+                pointerLine += U'^';
             }
-            pointerLine += U'^';
+            else 
+            {
+                lineContent = fileName;
+            }
+
+            coloredPrint(TC::LightBlue, std::format("    {}\n", lineContent.toBasicString()));
+
             coloredPrint(TC::LightGreen, std::format("    {}\n", pointerLine.toBasicString()));
             coloredPrint(TC::DarkGray, std::format("🔧 in function '{}' ({}:{})\n", err.src_loc.function_name(), err.src_loc.file_name(), err.src_loc.line()));
         }

src/Evaluator/Context/context.hpp

@@ -1,16 +1,22 @@
 #pragma once
 
-#include "Value/interface.hpp"
-#include <Value/Type.hpp>
 #include <algorithm>
+#include <cstddef>
+#include <functional>
 #include <unordered_map>
 #include <iostream>
 #include <memory>
 
-#include <Context/context_forward.hpp>
+#include <Ast/astBase.hpp>
+#include <Ast/Statements/InterfaceDefSt.hpp>
+#include <Evaluator/Value/function.hpp>
+#include <Evaluator/Value/interface.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Context/context_forward.hpp>
 #include <Core/fig_string.hpp>
-#include <Value/value.hpp>
-#include <Value/VariableSlot.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/VariableSlot.hpp>
+#include <Evaluator/Core/ExprResult.hpp>
 
 namespace Fig
 {
@@ -23,17 +29,35 @@ namespace Fig
         std::unordered_map<FString, Function> implMethods;
     };
 
+    struct OperationRecord
+    {
+        using UnaryOpFn = std::function<ExprResult(const ObjectPtr &)>;
+        using BinaryOpFn = std::function<ExprResult(const ObjectPtr &, const ObjectPtr &)>;
+
+        std::unordered_map<Ast::Operator, UnaryOpFn> unOpRec;
+        std::unordered_map<Ast::Operator, BinaryOpFn> binOpRec;
+
+        bool hasUnaryOp(Ast::Operator op) const { return unOpRec.contains(op); }
+
+        bool hasBinaryOp(Ast::Operator op) const { return binOpRec.contains(op); }
+
+        const UnaryOpFn &getUnaryOpFn(Ast::Operator op) const { return unOpRec.at(op); }
+
+        const BinaryOpFn &getBinaryOpFn(Ast::Operator op) const { return binOpRec.at(op); }
+    };
+
     class Context : public std::enable_shared_from_this<Context>
     {
     private:
         FString scopeName;
         std::unordered_map<FString, std::shared_ptr<VariableSlot>> variables;
 
-        std::unordered_map<std::size_t, Function> functions;
-        std::unordered_map<std::size_t, FString> functionNames;
+        // std::unordered_map<std::size_t, Function> functions;
+        // std::unordered_map<std::size_t, FString> functionNames;
 
         // implRegistry <Struct, ordered list of ImplRecord>
         std::unordered_map<TypeInfo, std::vector<ImplRecord>, TypeInfoHash> implRegistry;
+        std::unordered_map<TypeInfo, OperationRecord, TypeInfoHash> opRegistry;
 
     public:
         ContextPtr parent;
@@ -50,14 +74,25 @@ namespace Fig
         void merge(const Context &c)
         {
             variables.insert(c.variables.begin(), c.variables.end());
-            functions.insert(c.functions.begin(), c.functions.end());
-            functionNames.insert(c.functionNames.begin(), c.functionNames.end());
             implRegistry.insert(c.implRegistry.begin(), c.implRegistry.end());
+            opRegistry.insert(c.opRegistry.begin(), c.opRegistry.end());
             // structTypeNames.insert(c.structTypeNames.begin(),
             // c.structTypeNames.end());
         }
 
-        std::unordered_map<size_t, Function> getFunctions() const { return functions; }
+        std::unordered_map<size_t, Function> getFunctions() const
+        {
+            std::unordered_map<size_t, Function> result;
+            for (auto &[name, slot] : variables)
+            {
+                if (slot->declaredType == ValueType::Function)
+                {
+                    const Function &fn = slot->value->as<Function>();
+                    result[fn.id] = fn;
+                }
+            }
+            return result;
+        }
 
         std::shared_ptr<VariableSlot> get(const FString &name)
         {
@@ -121,12 +156,6 @@ namespace Fig
                     FString(std::format("Variable '{}' already defined in this scope", name.toBasicString())));
             }
             variables[name] = std::make_shared<VariableSlot>(name, value, ti, am);
-            if (ti == ValueType::Function and value->getTypeInfo() == ValueType::Function)
-            {
-                auto &fn = value->as<Function>();
-                functions[fn.id] = fn;
-                functionNames[fn.id] = name;
-            }
             // if (ti == ValueType::StructType)
             // {
             //     auto &st = value->as<StructType>();
@@ -141,34 +170,20 @@ namespace Fig
                 throw RuntimeError(
                     FString(std::format("Variable '{}' already defined in this scope", name.toBasicString())));
             }
-            variables[name] = std::make_shared<VariableSlot>(
-                name,
-                target->value,
-                ti,
-                am,
-                true,
-                target
-            );
-        }
-        std::optional<Function> getFunction(std::size_t id)
-        {
-            auto it = functions.find(id);
-            if (it != functions.end()) { return it->second; }
-            else if (parent) { return parent->getFunction(id); }
-            else
-            {
-                return std::nullopt;
-            }
+            variables[name] = std::make_shared<VariableSlot>(name, target->value, ti, am, true, target);
         }
+
         std::optional<FString> getFunctionName(std::size_t id)
         {
-            auto it = functionNames.find(id);
-            if (it != functionNames.end()) { return it->second; }
-            else if (parent) { return parent->getFunctionName(id); }
-            else
+            for (auto &[name, slot] : variables)
             {
-                return std::nullopt;
+                if (slot->declaredType == ValueType::Function)
+                {
+                    const Function &fn = slot->value->as<Function>();
+                    if (fn.id == id) { return name; }
+                }
             }
+            return std::nullopt;
         }
         // std::optional<FString> getStructName(std::size_t id)
         // {
@@ -232,6 +247,13 @@ namespace Fig
             return parent && parent->hasImplRegisted(structType, interfaceType);
         }
 
+        std::unordered_map<TypeInfo, std::vector<ImplRecord>, TypeInfoHash> getImplRegistry() const
+        {
+            return implRegistry;
+        }
+
+        std::unordered_map<TypeInfo, std::vector<ImplRecord>, TypeInfoHash> &getImplRegistry() { return implRegistry; }
+
         std::optional<ImplRecord> getImplRecord(const TypeInfo &structType, const TypeInfo &interfaceType) const
         {
             auto it = implRegistry.find(structType);
@@ -303,7 +325,7 @@ namespace Fig
             return false;
         }
 
-        Function getDefaultImplementedMethod(const TypeInfo &structType, const FString &functionName)
+        Ast::InterfaceMethod getDefaultImplementedMethod(const TypeInfo &structType, const FString &functionName)
         {
             // O(N²)
             // SLOW
@@ -336,15 +358,12 @@ namespace Fig
                     if (method.name == functionName)
                     {
                         if (!method.hasDefaultBody()) assert(false);
-
-                        return Function(
-                            method.paras, TypeInfo(method.returnType), method.defaultBody, shared_from_this());
+                        return method;
                     }
                 }
             }
 
             assert(false);
-            return Function(); // ignore warning
         }
 
         const Function &getImplementedMethod(const TypeInfo &structType, const FString &functionName) const
@@ -365,6 +384,74 @@ namespace Fig
             throw "";      // ignore warning
         }
 
+        std::unordered_map<TypeInfo, OperationRecord, TypeInfoHash> &getOpRegistry() { return opRegistry; }
+
+        bool hasOperatorImplemented(const TypeInfo &type, Ast::Operator op, bool isUnary = false) const
+        {
+            auto it = opRegistry.find(type);
+            if (it != opRegistry.end())
+            {
+                const OperationRecord &rec = it->second;
+                if (isUnary)
+                    return rec.hasUnaryOp(op);
+                else
+                    return rec.hasBinaryOp(op);
+            }
+
+            if (parent) return parent->hasOperatorImplemented(type, op, isUnary);
+            return false;
+        }
+
+        std::optional<OperationRecord::UnaryOpFn> getUnaryOperatorFn(const TypeInfo &type, Ast::Operator op) const
+        {
+            auto it = opRegistry.find(type);
+            if (it != opRegistry.end())
+            {
+                const OperationRecord &rec = it->second;
+                if (rec.hasUnaryOp(op)) return rec.getUnaryOpFn(op);
+            }
+
+            if (parent) return parent->getUnaryOperatorFn(type, op);
+            return std::nullopt;
+        }
+
+        std::optional<OperationRecord::BinaryOpFn> getBinaryOperatorFn(const TypeInfo &type, Ast::Operator op) const
+        {
+            auto it = opRegistry.find(type);
+            if (it != opRegistry.end())
+            {
+                const OperationRecord &rec = it->second;
+                if (rec.hasBinaryOp(op)) return rec.getBinaryOpFn(op);
+            }
+
+            if (parent) return parent->getBinaryOperatorFn(type, op);
+            return std::nullopt;
+        }
+
+        void registerUnaryOperator(const TypeInfo &type, Ast::Operator op, OperationRecord::UnaryOpFn fn)
+        {
+            opRegistry[type].unOpRec[op] = std::move(fn);
+        }
+
+        void registerBinaryOperator(const TypeInfo &type, Ast::Operator op, OperationRecord::BinaryOpFn fn)
+        {
+            opRegistry[type].binOpRec[op] = std::move(fn);
+        }
+
+        bool removeUnaryOperator(const TypeInfo &type, Ast::Operator op)
+        {
+            auto it = opRegistry.find(type);
+            if (it != opRegistry.end()) return it->second.unOpRec.erase(op) > 0;
+            return false;
+        }
+
+        bool removeBinaryOperator(const TypeInfo &type, Ast::Operator op)
+        {
+            auto it = opRegistry.find(type);
+            if (it != opRegistry.end()) return it->second.binOpRec.erase(op) > 0;
+            return false;
+        }
+
         void printStackTrace(std::ostream &os = std::cerr, int indent = 0) const
         {
             const Context *ctx = this;

src/Evaluator/Core/Eval.cpp

@@ -0,0 +1,107 @@
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+#include <Evaluator/Core/ExprResult.hpp>
+
+namespace Fig
+{
+    ExprResult Evaluator::eval(Ast::Expression exp, ContextPtr ctx)
+    {
+        using Ast::AstType;
+        AstType type = exp->getType();
+        switch (type)
+        {
+            case AstType::ValueExpr: {
+                auto val = std::static_pointer_cast<Ast::ValueExprAst>(exp);
+               
+                return val->val;
+            }
+            case AstType::VarExpr: {
+                auto varExpr = std::static_pointer_cast<Ast::VarExprAst>(exp);
+
+                return check_unwrap_lv(evalVarExpr(varExpr, ctx)).get(); // LvObject -> RvObject
+            }
+            case AstType::BinaryExpr: {
+                auto bin = std::static_pointer_cast<Ast::BinaryExprAst>(exp);
+               
+                return evalBinary(bin, ctx);
+            }
+            case AstType::UnaryExpr: {
+                auto un = std::static_pointer_cast<Ast::UnaryExprAst>(exp);
+               
+                return evalUnary(un, ctx);
+            }
+            case AstType::TernaryExpr: {
+                auto te = std::static_pointer_cast<Ast::TernaryExprAst>(exp);
+               
+                return evalTernary(te, ctx);
+            }
+            case AstType::MemberExpr:
+            case AstType::IndexExpr: return check_unwrap_lv(evalLv(exp, ctx)).get();
+
+            case AstType::FunctionCall: {
+                auto fnCall = std::static_pointer_cast<Ast::FunctionCallExpr>(exp);
+                return evalFunctionCall(fnCall, ctx);
+            }
+            case AstType::FunctionLiteralExpr: {
+                auto fnLiteral = std::static_pointer_cast<Ast::FunctionLiteralExprAst>(exp);
+               
+
+                Ast::BlockStatement body = nullptr;
+                if (fnLiteral->isExprMode())
+                {
+                    Ast::Expression exprBody = fnLiteral->getExprBody();
+                   
+
+                    const Ast::AstAddressInfo &aai = exprBody->getAAI();
+                    Ast::Return st = std::make_shared<Ast::ReturnSt>(exprBody);
+                    st->setAAI(aai);
+
+                    body = std::make_shared<Ast::BlockStatementAst>();
+                    body->stmts.push_back(st); // convert to Ast::Statement
+                    body->setAAI(aai);
+                }
+                else
+                {
+                    body = fnLiteral->getBlockBody();
+                   
+                }
+                Function fn(FString(std::format("<LambdaFn>")),fnLiteral->paras, ValueType::Any, body, ctx
+                            /*
+                                pass the ctx(fnLiteral eval context) as closure context
+                            */
+                );
+                return std::make_shared<Object>(std::move(fn));
+            }
+            case AstType::InitExpr: {
+                auto initExpr = std::static_pointer_cast<Ast::InitExprAst>(exp);
+               
+                return evalInitExpr(initExpr, ctx);
+            }
+
+            case AstType::ListExpr: {
+                auto lstExpr = std::static_pointer_cast<Ast::ListExprAst>(exp);
+               
+
+                List list;
+                for (auto &exp : lstExpr->val) { list.push_back(check_unwrap(eval(exp, ctx))); }
+                return std::make_shared<Object>(std::move(list));
+            }
+
+            case AstType::MapExpr: {
+                auto mapExpr = std::static_pointer_cast<Ast::MapExprAst>(exp);
+               
+
+                Map map;
+                for (auto &[key, value] : mapExpr->val) {
+                    map[check_unwrap(eval(key, ctx))] = check_unwrap(eval(value, ctx));
+                }
+                return std::make_shared<Object>(std::move(map));
+            }
+
+            default: {
+                throw RuntimeError(FString(std::format("err type of expr: {}", magic_enum::enum_name(type))));
+            }
+        }
+        return Object::getNullInstance(); // ignore warning
+    }
+};

src/Evaluator/Core/EvalBinary.cpp

@@ -0,0 +1,437 @@
+#include <Ast/Expressions/BinaryExpr.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/Value/IntPool.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+#include <Evaluator/Core/ExprResult.hpp>
+
+#include <exception>
+#include <memory>
+#include <functional>
+
+namespace Fig
+{
+    ExprResult Evaluator::evalBinary(Ast::BinaryExpr bin, ContextPtr ctx)
+    {
+        using Ast::Operator;
+        Operator op = bin->op;
+        Ast::Expression lexp = bin->lexp, rexp = bin->rexp;
+
+        const auto &tryInvokeOverloadFn =
+            [ctx, op](const ObjectPtr &lhs, const ObjectPtr &rhs, const std::function<ExprResult()> &rollback) {
+                if (lhs->is<StructInstance>() && lhs->getTypeInfo() == rhs->getTypeInfo())
+                {
+                    // 运算符重载
+                    const TypeInfo &type = actualType(lhs);
+                    if (ctx->hasOperatorImplemented(type, op))
+                    {
+                        const auto &fnOpt = ctx->getBinaryOperatorFn(type, op);
+                        return (*fnOpt)(lhs, rhs);
+                    }
+                }
+                return rollback();
+            };
+
+        switch (op)
+        {
+            case Operator::Add: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() + rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(*lhs + *rhs);
+                });
+            }
+            case Operator::Subtract: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() - rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(*lhs - *rhs);
+                });
+            }
+            case Operator::Multiply: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() * rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(*lhs * *rhs);
+                });
+            }
+            case Operator::Divide: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs / *rhs); });
+            }
+            case Operator::Modulo: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass lv = lhs->as<ValueType::IntClass>();
+                        ValueType::IntClass rv = rhs->as<ValueType::IntClass>();
+                        if (rv == 0) { throw ValueError(FString(std::format("Modulo by zero: {} % {}", lv, rv))); }
+                        ValueType::IntClass result = lv / rv;
+                        ValueType::IntClass r = lv % rv;
+                        if (r != 0 && ((lv < 0) != (rv < 0))) { result -= 1; }
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(*lhs % *rhs);
+                });
+            }
+
+            case Operator::Is: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs, ctx, bin]() {
+                    const TypeInfo &lhsType = lhs->getTypeInfo();
+                    const TypeInfo &rhsType = rhs->getTypeInfo();
+
+                    if (lhs->is<StructInstance>() && rhs->is<StructType>())
+                    {
+                        const StructInstance &si = lhs->as<StructInstance>();
+                        const StructType &st = rhs->as<StructType>();
+                        return std::make_shared<Object>(si.parentType == st.type);
+                    }
+                    if (lhs->is<StructInstance>() && rhs->is<InterfaceType>())
+                    {
+                        const StructInstance &si = lhs->as<StructInstance>();
+                        const InterfaceType &it = rhs->as<InterfaceType>();
+                        return std::make_shared<Object>(implements(si.parentType, it.type, ctx));
+                    }
+
+                    if (ValueType::isTypeBuiltin(lhsType) && rhsType == ValueType::StructType)
+                    {
+                        const StructType &st = rhs->as<StructType>();
+                        const TypeInfo &type = st.type;
+                        /*
+                            如果是内置类型(e.g. Int, String)
+                            那么 eval出来String这个字，出来的是StructType
+                            而出来的StructType.type就不会是一个独立的TypeInfo,而是内置的ValueType::String
+                            依次我们可以判断内置类型
+
+                            e.g:
+                                "123" is String
+                                  L   OP    R
+
+                            其中 L 类型为 String
+                            而 R 类型为 StructType (builtins.hpp) 中注册
+                            拿到 R 的 StructType, 其中的 type 为 String
+                        */
+                        if (lhs->getTypeInfo() == type) { return Object::getTrueInstance(); }
+                        return Object::getFalseInstance();
+                    }
+
+                    throw EvaluatorError(u8"TypeError",
+                                         std::format("Unsupported operator `is` for '{}' && '{}'",
+                                                     prettyType(lhs).toBasicString(),
+                                                     prettyType(rhs).toBasicString()),
+                                         bin->lexp);
+                });
+            }
+
+            case Operator::As: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs, ctx, bin, this]() -> ExprResult {
+                    if (!rhs->is<StructType>())
+                    {
+                        throw EvaluatorError(
+                            u8"OperatorError",
+                            std::format("Operator `as` requires right hand side operand a struct type, but got '{}'",
+                                        prettyType(rhs).toBasicString()),
+                            bin->rexp);
+                    }
+                    const StructType &targetStructType = rhs->as<StructType>();
+                    const TypeInfo &targetType = targetStructType.type;
+                    const TypeInfo &sourceType = lhs->getTypeInfo();
+                    if (targetType == sourceType) { return lhs; }
+                    if (targetType == ValueType::String) { return std::make_shared<Object>(lhs->toStringIO()); }
+                    if (sourceType == ValueType::Int)
+                    {
+                        if (targetType == ValueType::Double)
+                        {
+                            return std::make_shared<Object>(
+                                static_cast<ValueType::DoubleClass>(lhs->as<ValueType::IntClass>()));
+                        }
+                    }
+                    else if (sourceType == ValueType::Double)
+                    {
+                        if (targetType == ValueType::Int)
+                        {
+                            return IntPool::getInstance().createInt(
+                                static_cast<ValueType::IntClass>(lhs->as<ValueType::DoubleClass>()));
+                        }
+                    }
+                    else if (sourceType == ValueType::String)
+                    {
+                        const FString &str = lhs->as<ValueType::StringClass>();
+                        if (targetType == ValueType::Int)
+                        {
+                            try
+                            {
+                                return IntPool::getInstance().createInt(
+                                    static_cast<ValueType::IntClass>(std::stoll(str.toBasicString())));
+                            }
+                            catch (std::exception &e)
+                            {
+                                return ExprResult::error(
+                                    genTypeError(FString(std::format("Cannot cast type `{}` to `{}`, bad int string {}",
+                                                                     prettyType(lhs).toBasicString(),
+                                                                     prettyType(rhs).toBasicString(),
+                                                                     str.toBasicString())),
+                                                 bin->rexp,
+                                                 ctx));
+                            }
+                        }
+                        if (targetType == ValueType::Double)
+                        {
+                            try
+                            {
+                                return std::make_shared<Object>(std::stod(str.toBasicString()));
+                            }
+                            catch (std::exception &e)
+                            {
+                                return ExprResult::error(genTypeError(
+                                    FString(std::format("Cannot cast type `{}` to `{}`, bad double string {}",
+                                                        prettyType(lhs).toBasicString(),
+                                                        prettyType(rhs).toBasicString(),
+                                                        str.toBasicString())),
+                                    bin->rexp,
+                                    ctx));
+                            }
+                        }
+                        if (targetType == ValueType::Bool)
+                        {
+                            if (str == u8"true") { return Object::getTrueInstance(); }
+                            else if (str == u8"false") { return Object::getFalseInstance(); }
+                            return ExprResult::error(
+                                genTypeError(FString(std::format("Cannot cast type `{}` to `{}`, bad bool string {}",
+                                                                 prettyType(lhs).toBasicString(),
+                                                                 prettyType(rhs).toBasicString(),
+                                                                str.toBasicString())),
+                                             bin->rexp,
+                                             ctx));
+                        }
+                    }
+                    else if (sourceType == ValueType::Bool)
+                    {
+                        if (targetType == ValueType::Int)
+                        {
+                            return IntPool::getInstance().createInt(static_cast<ValueType::IntClass>(lhs->as<ValueType::BoolClass>()));
+                        }
+                        if (targetType == ValueType::Double)
+                        {
+                            return std::make_shared<Object>(static_cast<ValueType::DoubleClass>(lhs->as<ValueType::BoolClass>()));
+                        }
+                    }
+
+                    return ExprResult::error(genTypeError(FString(std::format("Cannot cast type `{}` to `{}`",
+                                                                              prettyType(lhs).toBasicString(),
+                                                                              prettyType(rhs).toBasicString())),
+                                                          bin->rexp,
+                                                          ctx));
+                });
+            }
+
+            case Operator::BitAnd: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() & rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(bit_and(*lhs, *rhs));
+                });
+            }
+
+            case Operator::BitOr: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() | rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(bit_or(*lhs, *rhs));
+                });
+            }
+
+            case Operator::BitXor: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() ^ rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(bit_xor(*lhs, *rhs));
+                });
+            }
+
+            case Operator::ShiftLeft: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() << rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(shift_left(*lhs, *rhs));
+                });
+            }
+            case Operator::ShiftRight: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() {
+                    if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs->as<ValueType::IntClass>() >> rhs->as<ValueType::IntClass>();
+                        return IntPool::getInstance().createInt(result);
+                    }
+                    return std::make_shared<Object>(shift_right(*lhs, *rhs));
+                });
+            }
+
+            case Operator::Assign: {
+                LvObject lv = check_unwrap_lv(evalLv(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                lv.set(rhs);
+                return rhs;
+            }
+
+            case Operator::And: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                if (lhs->is<bool>() && !isBoolObjectTruthy(lhs)) { return Object::getFalseInstance(); }
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs && *rhs); });
+            }
+
+            case Operator::Or: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                if (lhs->is<bool>() && isBoolObjectTruthy(lhs)) { return Object::getTrueInstance(); }
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs || *rhs); });
+            }
+
+            case Operator::Equal: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs == *rhs); });
+            }
+
+            case Operator::NotEqual: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs != *rhs); });
+            }
+
+            case Operator::Less: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs < *rhs); });
+            }
+
+            case Operator::LessEqual: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs <= *rhs); });
+            }
+
+            case Operator::Greater: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs > *rhs); });
+            }
+
+            case Operator::GreaterEqual: {
+                ObjectPtr lhs = check_unwrap(eval(lexp, ctx));
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                return tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs >= *rhs); });
+            }
+
+            case Operator::PlusAssign: {
+                LvObject lv = check_unwrap_lv(evalLv(lexp, ctx));
+                const ObjectPtr &lhs = lv.get();
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                const ObjectPtr &result = check_unwrap(
+                    tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs + *rhs); }));
+                lv.set(result);
+                return rhs;
+            }
+
+            case Operator::MinusAssign: {
+                LvObject lv = check_unwrap_lv(evalLv(lexp, ctx));
+                const ObjectPtr &lhs = lv.get();
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                const ObjectPtr &result = check_unwrap(
+                    tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs - *rhs); }));
+                lv.set(result);
+                return rhs;
+            }
+
+            case Operator::AsteriskAssign: {
+                LvObject lv = check_unwrap_lv(evalLv(lexp, ctx));
+                const ObjectPtr &lhs = lv.get();
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                const ObjectPtr &result = check_unwrap(
+                    tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs * *rhs); }));
+                lv.set(result);
+                return rhs;
+            }
+
+            case Operator::SlashAssign: {
+                LvObject lv = check_unwrap_lv(evalLv(lexp, ctx));
+                const ObjectPtr &lhs = lv.get();
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                const ObjectPtr &result = check_unwrap(
+                    tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs / *rhs); }));
+                lv.set(result);
+                return rhs;
+            }
+
+            case Operator::PercentAssign: {
+                LvObject lv = check_unwrap_lv(evalLv(lexp, ctx));
+                const ObjectPtr &lhs = lv.get();
+                ObjectPtr rhs = check_unwrap(eval(rexp, ctx));
+                const ObjectPtr &result = check_unwrap(
+                    tryInvokeOverloadFn(lhs, rhs, [lhs, rhs]() { return std::make_shared<Object>(*lhs % *rhs); }));
+                lv.set(result);
+                return rhs;
+            }
+
+            default:
+                throw EvaluatorError(u8"UnsupportedOp",
+                                     std::format("Unsupport operator '{}' for binary", magic_enum::enum_name(op)),
+                                     bin);
+        }
+    }
+}; // namespace Fig

src/Evaluator/Core/EvalFunctionCall.cpp

@@ -0,0 +1,206 @@
+#include <Ast/functionParameters.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Ast/Expressions/FunctionCall.hpp>
+#include <Evaluator/Value/function.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+#include <Evaluator/Core/ExprResult.hpp>
+
+namespace Fig
+{
+   ExprResult Evaluator::executeFunction(const Function &fn,
+                                        const Ast::FunctionCallArgs &args,
+                                        ContextPtr fnCtx) // new context for fn, already filled paras
+    {
+        // const FString &fnName = fn.name;
+        if (fn.type == Function::Builtin || fn.type == Function::MemberType)
+        {
+            if (fn.type == Function::Builtin) { return fn.builtin(args.argv); }
+            else
+            {
+                return fn.mtFn(nullptr,
+                               args.argv); // wrapped member type function (`this` provided by evalMemberExpr)
+            }
+        }
+        // else: normal fn, args is needless
+        for (const auto &stmt : fn.body->stmts)
+        {
+            StatementResult sr = evalStatement(stmt, fnCtx);
+            if (sr.isError())
+            {
+                handle_error(sr, stmt, fnCtx);
+            }
+            if (!sr.isNormal())
+            {
+                return sr.result;
+            }
+        }
+        return Object::getNullInstance();
+    }
+    ExprResult Evaluator::evalFunctionCall(const Ast::FunctionCall &call, ContextPtr ctx)
+    {
+        RvObject fnObj = check_unwrap(eval(call->callee, ctx));
+        if (fnObj->getTypeInfo() != ValueType::Function)
+        {
+            throw EvaluatorError(u8"ObjectNotCallable",
+                                 std::format("Object `{}` isn't callable", fnObj->toString().toBasicString()),
+                                 call->callee);
+        }
+
+        const Function &fn = fnObj->as<Function>();
+
+        const FString &fnName = fn.name;
+        const Ast::FunctionArguments &fnArgs = call->arg;
+
+        Ast::FunctionCallArgs evaluatedArgs;
+        if (fn.type == Function::Builtin || fn.type == Function::MemberType)
+        {
+            for (const auto &argExpr : fnArgs.argv) { evaluatedArgs.argv.push_back(check_unwrap(eval(argExpr, ctx))); }
+            if (fn.builtinParamCount != -1 && fn.builtinParamCount != evaluatedArgs.getLength())
+            {
+                throw EvaluatorError(u8"BuiltinArgumentMismatchError",
+                                     std::format("Builtin function '{}' expects {} arguments, but {} were provided",
+                                                 fnName.toBasicString(),
+                                                 fn.builtinParamCount,
+                                                 evaluatedArgs.getLength()),
+                                     (fnArgs.getLength() > 0 ? fnArgs.argv.back() : call));
+            }
+            return executeFunction(fn, evaluatedArgs, nullptr);
+        }
+
+        // check argument, all types of parameters
+        Ast::FunctionParameters fnParas = fn.paras;
+
+        // create new context for function call
+        auto newContext = std::make_shared<Context>(FString(std::format("<Function {}()>", fnName.toBasicString())),
+                                                    fn.closureContext);
+
+        if (fnParas.variadic)
+            goto VariadicFilling;
+        else
+            goto NormalFilling;
+
+    NormalFilling: {
+        if (fnArgs.getLength() < fnParas.posParas.size() || fnArgs.getLength() > fnParas.size())
+        {
+            throw RuntimeError(FString(std::format("Function '{}' expects {} to {} arguments, but {} were provided",
+                                                   fnName.toBasicString(),
+                                                   fnParas.posParas.size(),
+                                                   fnParas.size(),
+                                                   fnArgs.getLength())));
+        }
+
+        // positional parameters type check
+        size_t i;
+        for (i = 0; i < fnParas.posParas.size(); i++)
+        {
+            const TypeInfo &expectedType = actualType(check_unwrap(eval(fnParas.posParas[i].second, fn.closureContext))); // look up type info, if exists a type
+                                                                                  // with the name, use it, else throw
+            ObjectPtr argVal = check_unwrap(eval(fnArgs.argv[i], ctx));
+            TypeInfo actualType = argVal->getTypeInfo();
+            if (!isTypeMatch(expectedType, argVal, fn.closureContext))
+            {
+                throw EvaluatorError(u8"ArgumentTypeMismatchError",
+                                     std::format("In function '{}', argument '{}' expects type '{}', but got type '{}'",
+                                                 fnName.toBasicString(),
+                                                 fnParas.posParas[i].first.toBasicString(),
+                                                 expectedType.toString().toBasicString(),
+                                                 actualType.toString().toBasicString()),
+                                     fnArgs.argv[i]);
+            }
+            evaluatedArgs.argv.push_back(argVal);
+        }
+        // default parameters type check
+        for (; i < fnArgs.getLength(); i++)
+        {
+            size_t defParamIndex = i - fnParas.posParas.size();
+            const TypeInfo &expectedType =
+                actualType(check_unwrap(eval(fnParas.defParas[defParamIndex].second.first, fn.closureContext)));
+
+            ObjectPtr defaultVal = check_unwrap(eval(fnParas.defParas[defParamIndex].second.second, fn.closureContext));
+            if (!isTypeMatch(expectedType, defaultVal, fn.closureContext))
+            {
+                throw EvaluatorError(
+                    u8"DefaultParameterTypeError",
+                    std::format(
+                        "In function '{}', default parameter '{}' has type '{}', which does not match the expected type '{}'",
+                        fnName.toBasicString(),
+                        fnParas.defParas[defParamIndex].first.toBasicString(),
+                        prettyType(defaultVal).toBasicString(),
+                        expectedType.toString().toBasicString()),
+                    fnArgs.argv[i]);
+            }
+
+            ObjectPtr argVal = check_unwrap(eval(fnArgs.argv[i], ctx));
+            TypeInfo actualType = argVal->getTypeInfo();
+            if (!isTypeMatch(expectedType, argVal, fn.closureContext))
+            {
+                throw EvaluatorError(u8"ArgumentTypeMismatchError",
+                                     std::format("In function '{}', argument '{}' expects type '{}', but got type '{}'",
+                                                 fnName.toBasicString(),
+                                                 fnParas.defParas[defParamIndex].first.toBasicString(),
+                                                 expectedType.toString().toBasicString(),
+                                                 actualType.toString().toBasicString()),
+                                     fnArgs.argv[i]);
+            }
+            evaluatedArgs.argv.push_back(argVal);
+        }
+        // default parameters filling
+        for (; i < fnParas.size(); i++)
+        {
+            size_t defParamIndex = i - fnParas.posParas.size();
+            ObjectPtr defaultVal = check_unwrap(eval(fnParas.defParas[defParamIndex].second.second, fn.closureContext));
+            evaluatedArgs.argv.push_back(defaultVal);
+        }
+
+        // define parameters in new context
+        for (size_t j = 0; j < fnParas.size(); j++)
+        {
+            FString paramName;
+            TypeInfo paramType;
+            if (j < fnParas.posParas.size())
+            {
+                paramName = fnParas.posParas[j].first;
+                paramType = actualType(check_unwrap(eval(fnParas.posParas[j].second, fn.closureContext)));
+            }
+            else
+            {
+                size_t defParamIndex = j - fnParas.posParas.size();
+                paramName = fnParas.defParas[defParamIndex].first;
+                paramType =
+                    actualType(check_unwrap(eval(fnParas.defParas[defParamIndex].second.first, fn.closureContext)));
+            }
+            AccessModifier argAm = AccessModifier::Normal;
+            newContext->def(paramName, paramType, argAm, evaluatedArgs.argv[j]);
+        }
+        goto ExecuteBody;
+    }
+
+    VariadicFilling: {
+        List list;
+        for (auto &exp : fnArgs.argv)
+        {
+            list.push_back(check_unwrap(eval(exp, ctx))); // eval arguments in current scope
+        }
+        newContext->def(fnParas.variadicPara, ValueType::List, AccessModifier::Normal, std::make_shared<Object>(list));
+        goto ExecuteBody;
+    }
+
+    ExecuteBody: {
+        // execute function body
+        ObjectPtr retVal = check_unwrap(executeFunction(fn, evaluatedArgs, newContext));
+
+        if (!isTypeMatch(fn.retType, retVal, ctx))
+        {
+            throw EvaluatorError(u8"ReturnTypeMismatchError",
+                                 std::format("Function '{}' expects return type '{}', but got type '{}'",
+                                             fnName.toBasicString(),
+                                             fn.retType.toString().toBasicString(),
+                                             prettyType(retVal).toBasicString()),
+                                 fn.body);
+        }
+        return retVal;
+    }
+    }
+}; // namespace Fig

src/Evaluator/Core/EvalInitExpr.cpp

@@ -0,0 +1,364 @@
+#include <Evaluator/Core/ExprResult.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    ExprResult Evaluator::evalInitExpr(Ast::InitExpr initExpr, ContextPtr ctx)
+    {
+        LvObject structeLv = check_unwrap_lv(evalLv(initExpr->structe, ctx));
+        ObjectPtr structTypeVal = structeLv.get();
+        const FString &structName = structeLv.name();
+        if (!structTypeVal->is<StructType>())
+        {
+            throw EvaluatorError(u8"NotAStructTypeError",
+                                 std::format("'{}' is not a structure type", structName.toBasicString()),
+                                 initExpr);
+        }
+        const StructType &structT = structTypeVal->as<StructType>();
+
+        if (structT.builtin)
+        {
+            const TypeInfo &type = structT.type;
+            auto &args = initExpr->args;
+            size_t argSize = args.size();
+
+            if (argSize > 1)
+            {
+                throw EvaluatorError(u8"StructInitArgumentMismatchError",
+                                     std::format("Builtin class `{}` expects 0 or 1 argument, but {} were provided",
+                                                 type.toString().toBasicString(),
+                                                 argSize),
+                                     initExpr);
+            }
+
+            // default value
+            if (argSize == 0)
+            {
+                if (type == ValueType::Any || type == ValueType::Null || type == ValueType::Function)
+                {
+                    throw EvaluatorError(
+                        u8"BuiltinNotConstructibleError",
+                        std::format("Builtin type `{}` cannot be constructed", type.toString().toBasicString()),
+                        initExpr);
+                }
+                return std::make_shared<Object>(Object::defaultValue(type));
+            }
+
+            ObjectPtr val = check_unwrap(eval(args[0].second, ctx));
+
+            auto err = [&](const char *msg) {
+                throw EvaluatorError(u8"BuiltinInitTypeMismatchError",
+                                     std::format("Builtin `{}` constructor {}", type.toString().toBasicString(), msg),
+                                     initExpr);
+            };
+
+            // ===================== Int =====================
+            if (type == ValueType::Int)
+            {
+                if (!val->is<ValueType::IntClass>()) err("expects Int");
+                return std::make_shared<Object>(val->as<ValueType::IntClass>());
+            }
+
+            // ===================== Double =====================
+            if (type == ValueType::Double)
+            {
+                if (!val->is<ValueType::DoubleClass>()) err("expects Double");
+                return std::make_shared<Object>(val->as<ValueType::DoubleClass>());
+            }
+
+            // ===================== Bool =====================
+            if (type == ValueType::Bool)
+            {
+                if (!val->is<ValueType::BoolClass>()) err("expects Bool");
+                return std::make_shared<Object>(val->as<ValueType::BoolClass>());
+            }
+
+            // ===================== String =====================
+            if (type == ValueType::String)
+            {
+                if (!val->is<ValueType::StringClass>()) err("expects String");
+                return std::make_shared<Object>(val->as<ValueType::StringClass>());
+            }
+
+            // ===================== Null =====================
+            if (type == ValueType::Null)
+            {
+                // Null basically ignores input but keep invariant strict:
+                if (!val->is<ValueType::NullClass>()) err("expects Null");
+                return Object::getNullInstance();
+            }
+
+            // ===================== List =====================
+            if (type == ValueType::List)
+            {
+                if (!val->is<List>()) err("expects List");
+
+                const auto &src = val->as<List>();
+                auto copied = std::make_shared<Object>(List{});
+
+                auto &dst = copied->as<List>();
+                dst.reserve(src.size());
+                for (auto &e : src) dst.push_back(e); // shallow element copy, but new container
+
+                return copied;
+            }
+
+            // ===================== Map =====================
+            if (type == ValueType::Map)
+            {
+                if (!val->is<Map>()) err("expects Map");
+
+                const auto &src = val->as<Map>();
+                auto copied = std::make_shared<Object>(Map{});
+
+                auto &dst = copied->as<Map>();
+                for (auto &[k, v] : src) dst.emplace(k, v);
+
+                return copied;
+            }
+
+            throw EvaluatorError(
+                u8"BuiltinNotConstructibleError",
+                std::format("Builtin type `{}` cannot be constructed", type.toString().toBasicString()),
+                initExpr);
+        }
+
+        ContextPtr defContext = structT.defContext; // definition context
+        // check init args
+
+        size_t minArgs = 0;
+        size_t maxArgs = structT.fields.size();
+
+        for (auto &f : structT.fields)
+        {
+            if (f.defaultValue == nullptr) minArgs++;
+        }
+
+        size_t got = initExpr->args.size();
+        if (got > maxArgs || got < minArgs)
+        {
+            throw EvaluatorError(u8"StructInitArgumentMismatchError",
+                                 std::format("Structure '{}' expects {} to {} fields, but {} were provided",
+                                             structName.toBasicString(),
+                                             minArgs,
+                                             maxArgs,
+                                             initExpr->args.size()),
+                                 initExpr);
+        }
+
+        std::vector<std::pair<FString, ObjectPtr>> evaluatedArgs;
+
+        auto evalArguments = [&evaluatedArgs, initExpr, ctx, this](){
+            for (const auto &[argName, argExpr] : initExpr->args)
+            {
+                evaluatedArgs.push_back({argName, check_unwrap(eval(argExpr, ctx))});
+            }
+            return ExprResult::normal(Object::getNullInstance());
+        };
+
+        ContextPtr instanceCtx =
+            std::make_shared<Context>(FString(std::format("<StructInstance {}>", structName.toBasicString())), defContext);
+        /*
+            3 ways of calling constructor
+            .1 Person {"Fig", 1, "IDK"};
+            .2 Person {name: "Fig", age: 1, sex: "IDK"}; // can be unordered
+            .3 Person {name, age, sex};
+        */
+        {
+            using enum Ast::InitExprAst::InitMode;
+            if (initExpr->initMode == Positional)
+            {
+                evalArguments();
+
+                for (size_t i = 0; i < maxArgs; ++i)
+                {
+                    const Field &field = structT.fields[i];
+                    const FString &fieldName = field.name;
+                    const TypeInfo &expectedType = field.type;
+                    if (i >= evaluatedArgs.size())
+                    {
+                        // we've checked argument count before, so here
+                        // must be a default value
+
+                        // evaluate default value in definition context
+                        ObjectPtr defaultVal = check_unwrap(eval(field.defaultValue,
+                                                                 ctx)); // it can't be null here
+
+                        // type check
+                        if (!isTypeMatch(expectedType, defaultVal, ctx))
+                        {
+                            throw EvaluatorError(
+                                u8"StructFieldTypeMismatchError",
+                                std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
+                                            structName.toBasicString(),
+                                            fieldName.toBasicString(),
+                                            expectedType.toString().toBasicString(),
+                                            prettyType(defaultVal).toBasicString()),
+                                initExpr);
+                        }
+
+                        instanceCtx->def(fieldName, expectedType, field.am, defaultVal);
+                        continue;
+                    }
+
+                    const ObjectPtr &argVal = evaluatedArgs[i].second;
+                    if (!isTypeMatch(expectedType, argVal, ctx))
+                    {
+                        throw EvaluatorError(
+                            u8"StructFieldTypeMismatchError",
+                            std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
+                                        structName.toBasicString(),
+                                        fieldName.toBasicString(),
+                                        expectedType.toString().toBasicString(),
+                                        prettyType(argVal).toBasicString()),
+                            initExpr);
+                    }
+                    instanceCtx->def(fieldName, expectedType, field.am, argVal);
+                }
+            }
+            else if (initExpr->initMode == Named)
+            {
+                evalArguments();
+
+                // named
+                for (size_t i = 0; i < maxArgs; ++i)
+                {
+                    const Field &field = structT.fields[i];
+                    const FString &fieldName = (field.name.empty() ? evaluatedArgs[i].first : field.name);
+                    if (instanceCtx->containsInThisScope(fieldName))
+                    {
+                        throw EvaluatorError(u8"StructFieldRedeclarationError",
+                                             std::format("Field '{}' already initialized in structure '{}'",
+                                                         fieldName.toBasicString(),
+                                                         structName.toBasicString()),
+                                             initExpr);
+                    }
+                    if (i + 1 > got)
+                    {
+                        // use default value                  //
+                        // evaluate default value in definition context
+                        ObjectPtr defaultVal = check_unwrap(eval(field.defaultValue,
+                                                                 defContext)); // it can't be null here
+
+                        // type check
+                        const TypeInfo &expectedType = field.type;
+                        if (!isTypeMatch(expectedType, defaultVal, ctx))
+                        {
+                            throw EvaluatorError(
+                                u8"StructFieldTypeMismatchError",
+                                std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
+                                            structName.toBasicString(),
+                                            fieldName.toBasicString(),
+                                            expectedType.toString().toBasicString(),
+                                            prettyType(defaultVal).toBasicString()),
+                                initExpr);
+                        }
+
+                        instanceCtx->def(fieldName, field.type, field.am, defaultVal);
+                        continue;
+                    }
+                    const ObjectPtr &argVal = evaluatedArgs[i].second;
+                    if (!isTypeMatch(field.type, argVal, ctx))
+                    {
+                        throw EvaluatorError(
+                            u8"StructFieldTypeMismatchError",
+                            std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
+                                        structName.toBasicString(),
+                                        fieldName.toBasicString(),
+                                        field.type.toString().toBasicString(),
+                                        prettyType(argVal).toBasicString()),
+                            initExpr);
+                    }
+                    instanceCtx->def(fieldName, field.type, field.am, argVal);
+                }
+            }
+            else
+            {
+                // shorthand, can be unordered
+                // in this mode, initExpr args are all VarExpr
+                // field name is the variable name
+                for (const auto &[argName, argExpr] : initExpr->args)
+                {
+                    // assert(argExpr->getType() == Ast::AstType::VarExpr);
+                    // argName is var name
+                    const ObjectPtr &argVal = check_unwrap(eval(argExpr, ctx)); // get the value
+                    // find field
+                    auto fieldIt = std::find_if(structT.fields.begin(),
+                                                structT.fields.end(),
+                                                [&argName](const Field &f) { return f.name == argName; });
+                    if (fieldIt == structT.fields.end())
+                    {
+                        // throw EvaluatorError(u8"StructFieldNotFoundError",
+                        //                      std::format("Field '{}' not found in structure '{}'",
+                        //                                  argName.toBasicString(),
+                        //                                  structName.toBasicString()),
+                        //                      initExpr);
+                        initExpr->initMode = Positional;
+                        return evalInitExpr(initExpr, ctx);
+                    }
+                    const Field &field = *fieldIt;
+                    if (!isTypeMatch(field.type, argVal, ctx))
+                    {
+                        throw EvaluatorError(
+                            u8"StructFieldTypeMismatchError",
+                            std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
+                                        structName.toBasicString(),
+                                        field.name.toBasicString(),
+                                        field.type.toString().toBasicString(),
+                                        prettyType(argVal).toBasicString()),
+                            initExpr);
+                    }
+                    // field.name is argName (var name)
+                    // Point{x=x, y=y} --> Point{x, y}
+
+                    instanceCtx->def(field.name, field.type, field.am, argVal);
+                }
+                // fill default values
+                size_t currentFieldCount =
+                    initExpr->args.size(); // we have already check argument count, min <= got <= max
+                // so remain fields start from currentFieldCount to maxArgs
+                for (size_t i = currentFieldCount; i < maxArgs; ++i)
+                {
+                    const Field &field = structT.fields[i];
+
+                    // evaluate default value in definition context
+                    ObjectPtr defaultVal = check_unwrap(eval(field.defaultValue,
+                                                             defContext)); // it can't be null here
+
+                    // type check
+                    if (!isTypeMatch(field.type, defaultVal, ctx))
+                    {
+                        throw EvaluatorError(
+                            u8"StructFieldTypeMismatchError",
+                            std::format("In structure '{}', field '{}' expects type '{}', but got type '{}'",
+                                        structName.toBasicString(),
+                                        field.name.toBasicString(),
+                                        field.type.toString().toBasicString(),
+                                        prettyType(defaultVal).toBasicString()),
+                            initExpr);
+                    }
+
+                    instanceCtx->def(field.name, field.type, field.am, defaultVal);
+                }
+            }
+        }
+        ContextPtr stDefCtx = structT.defContext;
+
+        // load struct method
+        for (auto &[id, fn] : stDefCtx->getFunctions())
+        {
+            const FString &funcName = fn.name;
+            const auto &funcSlot = stDefCtx->get(funcName);
+            
+            instanceCtx->def(funcName,
+                             ValueType::Function,
+                             funcSlot->am,
+                             std::make_shared<Object>(Function(funcName, fn.paras, fn.retType, fn.body, instanceCtx)));
+        }
+
+        return std::make_shared<Object>(StructInstance(structT.type, instanceCtx));
+    }
+};

src/Evaluator/Core/EvalLvObject.cpp

@@ -0,0 +1,248 @@
+#include "Evaluator/Core/ExprResult.hpp"
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    ExprResult Evaluator::evalVarExpr(Ast::VarExpr var, ContextPtr ctx)
+    {
+        const FString &name = var->name;
+
+        // 调试信息
+        // std::cerr << "=== DEBUG evalVarExpr ===" << std::endl;
+        // std::cerr << "Looking for: " << name.toBasicString() << std::endl;
+        // std::cerr << "Context: " << ctx->getScopeName().toBasicString() << std::endl;
+
+        // // 打印上下文
+        // ContextPtr current = ctx;
+        // int depth = 0;
+        // while (current)
+        // {
+        //     std::cerr << "  [" << depth << "] " << current->getScopeName().toBasicString();
+        //     if (current->containsInThisScope(name))
+        //     {
+        //         std::cerr << " -> FOUND HERE!" << std::endl;
+        //         auto slot = current->get(name);
+        //         std::cerr << "    Type: " << slot->declaredType.toString().toBasicString() << std::endl;
+        //         std::cerr << "    Value: " << (slot->value ? slot->value->toString().toBasicString() : "null")
+        //                   << std::endl;
+        //     }
+        //     else
+        //     {
+        //         std::cerr << " -> not found" << std::endl;
+        //     }
+        //     current = current->parent;
+        //     depth++;
+        // }
+        // end
+
+        if (!ctx->contains(name)) { throw EvaluatorError(u8"UndeclaredIdentifierError", name, var); }
+        return LvObject(ctx->get(name), ctx);
+    }
+    ExprResult Evaluator::evalMemberExpr(Ast::MemberExpr me, ContextPtr ctx)
+    {
+        // LvObject base = evalLv(me->base, ctx);
+        RvObject baseVal = check_unwrap(eval(me->base, ctx));
+        const FString &member = me->member;
+        if (baseVal->getTypeInfo() == ValueType::Module)
+        {
+            // std::cerr << "=== DEBUG evalMemberExpr (Module) ===" << std::endl;
+            // std::cerr << "Module object: " << baseVal->toString().toBasicString() << std::endl;
+
+            const Module &mod = baseVal->as<Module>();
+            // std::cerr << "Module context: " << mod.ctx->getScopeName().toBasicString() << std::endl;
+            // std::cerr << "Looking for member: " << member.toBasicString() << std::endl;
+
+            // if (mod.ctx->contains(member))
+            // {
+            //     std::cerr << "Found in module context!" << std::endl;
+            //     if (mod.ctx->isVariablePublic(member)) { std::cerr << "And it's public!" << std::endl; }
+            //     else
+            //     {
+            //         std::cerr << "But it's NOT public!" << std::endl;
+            //     }
+            // }
+            // else
+            // {
+            //     std::cerr << "NOT found in module context!" << std::endl;
+            // }
+            if (mod.ctx->contains(member) && mod.ctx->isVariablePublic(member))
+            {
+                return LvObject(mod.ctx->get(member), ctx);
+            }
+            else
+            {
+                throw EvaluatorError(u8"VariableNotFoundError",
+                                     std::format("`{}` has not variable '{}', check if it is public",
+                                                 baseVal->toString().toBasicString(),
+                                                 member.toBasicString()),
+                                     me->base);
+            }
+        }
+        if (baseVal->hasMemberFunction(member))
+        {
+            return LvObject(std::make_shared<VariableSlot>(
+                                member,
+                                std::make_shared<Object>(Function(
+                                    member,
+                                    [baseVal, member](ObjectPtr self, std::vector<ObjectPtr> args) -> ObjectPtr {
+                                        if (self) { return baseVal->getMemberFunction(member)(self, args); }
+                                        return baseVal->getMemberFunction(member)(baseVal, args);
+                                    },
+                                    baseVal->getMemberFunctionParaCount(member))),
+                                ValueType::Function,
+                                AccessModifier::PublicConst),
+                            ctx); // fake l-value
+        }
+
+        if (ctx->hasMethodImplemented(baseVal->getTypeInfo(), member))
+        {
+            // builtin type implementation!
+            // e.g. impl xxx for Int
+
+            auto &fn = ctx->getImplementedMethod(baseVal->getTypeInfo(), member);
+            Function boundFn(member,
+                             fn.paras,
+                             fn.retType,
+                             fn.body,
+                             ctx // current context
+            );
+            return LvObject(
+                std::make_shared<VariableSlot>(
+                    member, std::make_shared<Object>(boundFn), ValueType::Function, AccessModifier::PublicConst),
+                ctx);
+        }
+
+        if (baseVal->getTypeInfo() != ValueType::StructInstance) // and not member function found
+        {
+            throw EvaluatorError(
+                u8"NoAttributeError",
+                std::format("`{}` has not attribute '{}'", baseVal->toString().toBasicString(), member.toBasicString()),
+                me->base);
+        }
+        const StructInstance &si = baseVal->as<StructInstance>();
+        if (ctx->hasMethodImplemented(si.parentType, member))
+        {
+            auto &fn = ctx->getImplementedMethod(si.parentType, member);
+            Function boundFn(member,
+                             fn.paras,
+                             fn.retType,
+                             fn.body,
+                             si.localContext // create a new function and set closure context
+                                             // to struct instance context
+            );
+            return LvObject(
+                std::make_shared<VariableSlot>(
+                    member, std::make_shared<Object>(boundFn), ValueType::Function, AccessModifier::PublicConst),
+                ctx);
+        }
+        else if (si.localContext->containsInThisScope(member) && si.localContext->isVariablePublic(member))
+        {
+            return LvObject(si.localContext->get(member), ctx);
+        }
+        else if (ctx->hasDefaultImplementedMethod(si.parentType, member))
+        {
+            const auto &ifm = ctx->getDefaultImplementedMethod(si.parentType, member);
+            Function fn(member, ifm.paras, actualType(check_unwrap(eval(ifm.returnType, ctx))), ifm.defaultBody, ctx);
+
+            return LvObject(std::make_shared<VariableSlot>(
+                                member, std::make_shared<Object>(fn), ValueType::Function, AccessModifier::PublicConst),
+                            ctx);
+        }
+        else
+        {
+            throw EvaluatorError(u8"NoAttributeError",
+                                 std::format("`{}` has not attribute '{}' and no interfaces have been implemented it",
+                                             baseVal->toString().toBasicString(),
+                                             member.toBasicString()),
+                                 me->base);
+        }
+    }
+    ExprResult Evaluator::evalIndexExpr(Ast::IndexExpr ie, ContextPtr ctx)
+    {
+        RvObject base = check_unwrap(eval(ie->base, ctx));
+        RvObject index = check_unwrap(eval(ie->index, ctx));
+
+        const TypeInfo &type = base.get()->getTypeInfo();
+
+        if (type == ValueType::List)
+        {
+            if (index->getTypeInfo() != ValueType::Int)
+            {
+                throw EvaluatorError(
+                    u8"TypeError",
+                    std::format("Type `List` indices must be `Int`, got '{}'", prettyType(index).toBasicString()),
+                    ie->index);
+            }
+            List &list = base.get()->as<List>();
+            ValueType::IntClass indexVal = index->as<ValueType::IntClass>();
+            if (indexVal >= list.size())
+            {
+                throw EvaluatorError(
+                    u8"IndexOutOfRangeError",
+                    std::format("Index {} out of list `{}` range", indexVal, base->toString().toBasicString()),
+                    ie->index);
+            }
+            return LvObject(base, indexVal, LvObject::Kind::ListElement, ctx);
+        }
+        else if (type == ValueType::Map) { return LvObject(base, index, LvObject::Kind::MapElement, ctx); }
+        else if (type == ValueType::String)
+        {
+            if (index->getTypeInfo() != ValueType::Int)
+            {
+                throw EvaluatorError(
+                    u8"TypeError",
+                    std::format("Type `String` indices must be `Int`, got '{}'", prettyType(index).toBasicString()),
+                    ie->index);
+            }
+            FString &string = base->as<ValueType::StringClass>();
+            ValueType::IntClass indexVal = index->as<ValueType::IntClass>();
+            if (indexVal >= string.length())
+            {
+                throw EvaluatorError(
+                    u8"IndexOutOfRangeError",
+                    std::format("Index {} out of string `{}` range", indexVal, base->toString().toBasicString()),
+                    ie->index);
+            }
+            return LvObject(base, indexVal, LvObject::Kind::StringElement, ctx);
+        }
+        else
+        {
+            throw EvaluatorError(
+                u8"NoSubscriptableError",
+                std::format("`{}` object is not subscriptable", base->getTypeInfo().toString().toBasicString()),
+                ie->base);
+        }
+    }
+    ExprResult Evaluator::evalLv(Ast::Expression exp, ContextPtr ctx)
+    {
+        using Ast::Operator;
+        using Ast::AstType;
+        switch (exp->getType())
+        {
+            case AstType::VarExpr: {
+                Ast::VarExpr var = std::static_pointer_cast<Ast::VarExprAst>(exp);
+
+                return evalVarExpr(var, ctx);
+            }
+            case AstType::MemberExpr: {
+                Ast::MemberExpr me = std::static_pointer_cast<Ast::MemberExprAst>(exp);
+
+                return evalMemberExpr(me, ctx);
+            }
+            case AstType::IndexExpr: {
+                Ast::IndexExpr ie = std::static_pointer_cast<Ast::IndexExprAst>(exp);
+
+                return evalIndexExpr(ie, ctx);
+            }
+            default: {
+                throw EvaluatorError(
+                    u8"TypeError",
+                    std::format("Expression '{}' doesn't refer to a lvalue", exp->typeName().toBasicString()),
+                    exp);
+            }
+        }
+    }
+}; // namespace Fig

src/Evaluator/Core/EvalStatement.cpp

@@ -0,0 +1,674 @@
+#include <Evaluator/Core/ExprResult.hpp>
+#include <Ast/AccessModifier.hpp>
+#include <Ast/Expressions/FunctionCall.hpp>
+#include <Ast/astBase.hpp>
+#include <Ast/functionParameters.hpp>
+#include <Core/fig_string.hpp>
+#include <Evaluator/Core/StatementResult.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Value/structType.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+#include <Utils/utils.hpp>
+#include <unordered_map>
+
+namespace Fig
+{
+    StatementResult Evaluator::evalStatement(Ast::Statement stmt, ContextPtr ctx)
+    {
+        using enum Ast::AstType;
+        switch (stmt->getType())
+        {
+            case ImportSt: {
+                auto i = std::static_pointer_cast<Ast::ImportSt>(stmt);
+                return evalImportSt(i, ctx);
+            }
+            case VarDefSt: {
+                auto varDef = std::static_pointer_cast<Ast::VarDefAst>(stmt);
+
+                if (ctx->containsInThisScope(varDef->name))
+                {
+                    throw EvaluatorError(
+                        u8"RedeclarationError",
+                        std::format("Variable `{}` already declared in this scope", varDef->name.toBasicString()),
+                        varDef);
+                }
+
+                RvObject value = nullptr;
+                if (varDef->expr) { value = check_unwrap_stres(eval(varDef->expr, ctx)); }
+
+                TypeInfo declaredType; // default is Any
+                const Ast::Expression &declaredTypeExp = varDef->declaredType;
+
+                if (varDef->followupType) { declaredType = actualType(value); }
+                else if (declaredTypeExp)
+                {
+                    ObjectPtr declaredTypeValue = check_unwrap_stres(eval(declaredTypeExp, ctx));
+                    declaredType = actualType(declaredTypeValue);
+
+                    if (value != nullptr && !isTypeMatch(declaredType, value, ctx))
+                    {
+                        throw EvaluatorError(u8"TypeError",
+                                             std::format("Variable `{}` expects init-value type `{}`, but got '{}'",
+                                                         varDef->name.toBasicString(),
+                                                         prettyType(declaredTypeValue).toBasicString(),
+                                                         prettyType(value).toBasicString()),
+                                             varDef->expr);
+                    }
+                    else if (value == nullptr)
+                    {
+                        value = std::make_shared<Object>(Object::defaultValue(declaredType));
+                    } // else -> Ok
+                } // else -> type is Any (default)
+                AccessModifier am =
+                    (varDef->isConst ? (varDef->isPublic ? AccessModifier::PublicConst : AccessModifier::Const) :
+                                       (varDef->isPublic ? AccessModifier::Public : AccessModifier::Normal));
+                ctx->def(varDef->name, declaredType, am, value);
+                return StatementResult::normal();
+            }
+
+            case FunctionDefSt: {
+                auto fnDef = std::static_pointer_cast<Ast::FunctionDefSt>(stmt);
+
+                const FString &fnName = fnDef->name;
+                if (ctx->containsInThisScope(fnName))
+                {
+                    throw EvaluatorError(
+                        u8"RedeclarationError",
+                        std::format("Function `{}` already declared in this scope", fnName.toBasicString()),
+                        fnDef);
+                }
+                TypeInfo returnType = ValueType::Any;
+                if (fnDef->retType)
+                {
+                    ObjectPtr returnTypeValue = check_unwrap_stres(eval(fnDef->retType, ctx));
+                    returnType = actualType(returnTypeValue);
+                }
+
+                Function fn(fnName, fnDef->paras, returnType, fnDef->body, ctx);
+                ctx->def(fnName,
+                         ValueType::Function,
+                         (fnDef->isPublic ? AccessModifier::PublicConst : AccessModifier::Const),
+                         std::make_shared<Object>(fn));
+                return StatementResult::normal();
+            }
+
+            case StructSt: {
+                auto stDef = std::static_pointer_cast<Ast::StructDefSt>(stmt);
+
+                if (ctx->containsInThisScope(stDef->name))
+                {
+                    throw EvaluatorError(
+                        u8"RedeclarationError",
+                        std::format("Structure '{}' already defined in this scope", stDef->name.toBasicString()),
+                        stDef);
+                }
+
+                TypeInfo type(stDef->name, true); // register type name
+                ContextPtr defContext = std::make_shared<Context>(FString(std::format("<Struct {} at {}:{}>",
+                                                                                      stDef->name.toBasicString(),
+                                                                                      stDef->getAAI().line,
+                                                                                      stDef->getAAI().column)),
+                                                                  ctx);
+                ObjectPtr structTypeObj = std::make_shared<Object>(StructType(type, defContext, {}));
+
+                AccessModifier am = (stDef->isPublic ? AccessModifier::PublicConst : AccessModifier::Const);
+
+                ctx->def(stDef->name, ValueType::StructType, am, structTypeObj); // predef
+                defContext->def(stDef->name,
+                                ValueType::StructType,
+                                AccessModifier::Const,
+                                structTypeObj); // predef to itself, always const
+
+                std::vector<Field> fields;
+                std::vector<FString> _fieldNames;
+                for (Ast::StructDefField field : stDef->fields)
+                {
+                    if (Utils::vectorContains(field.fieldName, _fieldNames))
+                    {
+                        throw EvaluatorError(u8"RedeclarationError",
+                                             std::format("Field '{}' already defined in structure '{}'",
+                                                         field.fieldName.toBasicString(),
+                                                         stDef->name.toBasicString()),
+                                             stDef);
+                    }
+                    TypeInfo fieldType = ValueType::Any;
+                    if (field.declaredType)
+                    {
+                        ObjectPtr declaredTypeValue = check_unwrap_stres(eval(field.declaredType, ctx));
+                        fieldType = actualType(declaredTypeValue);
+                    }
+
+                    fields.push_back(Field(field.am, field.fieldName, fieldType, field.defaultValueExpr));
+                }
+                structTypeObj->as<StructType>().fields = fields;
+
+                const Ast::BlockStatement &body = stDef->body;
+                for (auto &st : body->stmts)
+                {
+                    if (st->getType() != Ast::AstType::FunctionDefSt)
+                    {
+                        throw EvaluatorError(u8"UnexpectedStatementInStructError",
+                                             std::format("Unexpected statement `{}` in struct declaration",
+                                                         st->toString().toBasicString()),
+                                             st);
+                    }
+                    evalStatement(st, defContext); // function def st
+                }
+                return StatementResult::normal();
+            }
+
+            case InterfaceDefSt: {
+                auto ifd = std::static_pointer_cast<Ast::InterfaceDefAst>(stmt);
+
+                const FString &interfaceName = ifd->name;
+
+                if (ctx->containsInThisScope(interfaceName))
+                {
+                    throw EvaluatorError(
+                        u8"RedeclarationError",
+                        std::format("Interface `{}` already declared in this scope", interfaceName.toBasicString()),
+                        ifd);
+                }
+                TypeInfo type(interfaceName, true); // register interface
+                ctx->def(interfaceName,
+                         type,
+                         (ifd->isPublic ? AccessModifier::PublicConst : AccessModifier::Const),
+                         std::make_shared<Object>(InterfaceType(type, ifd->methods)));
+                return StatementResult::normal();
+            }
+
+            case ImplementSt: {
+                auto ip = std::static_pointer_cast<Ast::ImplementAst>(stmt);
+
+                TypeInfo structType(ip->structName);
+                TypeInfo interfaceType(ip->interfaceName);
+                if (ctx->hasImplRegisted(structType, interfaceType))
+                {
+                    throw EvaluatorError(u8"DuplicateImplError",
+                                         std::format("Duplicate implement `{}` for `{}`",
+                                                     interfaceType.toString().toBasicString(),
+                                                     structType.toString().toBasicString()),
+                                         ip);
+                }
+                if (!ctx->contains(ip->interfaceName))
+                {
+                    throw EvaluatorError(u8"InterfaceNotFoundError",
+                                         std::format("Interface '{}' not found", ip->interfaceName.toBasicString()),
+                                         ip);
+                }
+                if (!ctx->contains(ip->structName))
+                {
+                    throw EvaluatorError(u8"StructNotFoundError",
+                                         std::format("Struct '{}' not found", ip->structName.toBasicString()),
+                                         ip);
+                }
+                auto interfaceSlot = ctx->get(ip->interfaceName);
+                auto structSlot = ctx->get(ip->structName);
+
+                LvObject interfaceLv(interfaceSlot, ctx);
+                LvObject structLv(structSlot, ctx);
+
+                ObjectPtr interfaceObj = interfaceLv.get();
+                ObjectPtr structTypeObj = structLv.get();
+
+                if (!interfaceObj->is<InterfaceType>())
+                {
+                    throw EvaluatorError(
+                        u8"NotAInterfaceError",
+                        std::format("Variable `{}` is not a interface", ip->interfaceName.toBasicString()),
+                        ip);
+                }
+                if (!structTypeObj->is<StructType>())
+                {
+                    throw EvaluatorError(
+                        u8"NotAStructType",
+                        std::format("Variable `{}` is not a struct type", ip->structName.toBasicString()),
+                        ip);
+                }
+
+                auto &implementMethods = ip->methods;
+
+                if (ip->interfaceName == u8"Operation")
+                {
+                    // 运算符重载
+                    /*
+                    impl Operation for xxx
+                    {
+                        add(l, r) {...}
+                    }
+                    */
+                    if (ValueType::isTypeBuiltin(structType))
+                    {
+                        throw EvaluatorError(u8"BadUserError",
+                                             std::format("Don't overload built-in type operators plz! `{}`",
+                                                         prettyType(structTypeObj).toBasicString()),
+                                             ip);
+                    }
+
+                    using enum Ast::Operator;
+                    static const std::unordered_map<FString, std::pair<Ast::Operator, size_t>> magic_name_to_op = {
+                        // 算术
+                        {u8"Add", {Ast::Operator::Add, 2}},
+                        {u8"Sub", {Ast::Operator::Subtract, 2}},
+                        {u8"Mul", {Ast::Operator::Multiply, 2}},
+                        {u8"Div", {Ast::Operator::Divide, 2}},
+                        {u8"Mod", {Ast::Operator::Modulo, 2}},
+                        {u8"Pow", {Ast::Operator::Power, 2}},
+
+                        // 逻辑（一元）
+                        {u8"Neg", {Ast::Operator::Subtract, 1}}, // 一元负号
+                        {u8"Not", {Ast::Operator::Not, 1}},
+
+                        // 逻辑（二元）
+                        {u8"And", {Ast::Operator::And, 2}},
+                        {u8"Or", {Ast::Operator::Or, 2}},
+
+                        // 比较
+                        {u8"Equal", {Ast::Operator::Equal, 2}},
+                        {u8"NotEqual", {Ast::Operator::NotEqual, 2}},
+                        {u8"LessThan", {Ast::Operator::Less, 2}},
+                        {u8"LessEqual", {Ast::Operator::LessEqual, 2}},
+                        {u8"GreaterThan", {Ast::Operator::Greater, 2}},
+                        {u8"GreaterEqual", {Ast::Operator::GreaterEqual, 2}},
+                        {u8"Is", {Ast::Operator::Is, 2}},
+
+                        // 位运算（一元）
+                        {u8"BitNot", {Ast::Operator::BitNot, 1}},
+
+                        // 位运算（二元）
+                        {u8"BitAnd", {Ast::Operator::BitAnd, 2}},
+                        {u8"BitOr", {Ast::Operator::BitOr, 2}},
+                        {u8"BitXor", {Ast::Operator::BitXor, 2}},
+                        {u8"ShiftLeft", {Ast::Operator::ShiftLeft, 2}},
+                        {u8"ShiftRight", {Ast::Operator::ShiftRight, 2}},
+                    };
+                    for (auto &implMethod : implementMethods)
+                    {
+                        const FString &opName = implMethod.name;
+                        if (!magic_name_to_op.contains(opName))
+                        {
+                            // ... 现在忽略
+                            // 未来可能报错
+
+                            continue;
+                        }
+
+                        auto [op, expectArgCnt] = magic_name_to_op.at(opName);
+
+                        //                                  type          op     isUnary(1-->true, 2-->false)
+                        if (ctx->hasOperatorImplemented(structType, op, (expectArgCnt == 1 ? true : false)))
+                        {
+                            throw EvaluatorError(
+                                u8"DuplicateImplementError",
+                                std::format("{} has already implement by another interface", opName.toBasicString()),
+                                ip);
+                        }
+
+                        size_t paraCnt = implMethod.paras.posParas.size(); // 必须为位置参数!
+                        if (paraCnt != expectArgCnt || implMethod.paras.size() != expectArgCnt)
+                        {
+                            // 特化报错，更详细易读
+                            throw EvaluatorError(u8"InterfaceSignatureMismatch",
+                                                 std::format("Operator {} for {} arg count must be {}, got {}",
+                                                             opName.toBasicString(),
+                                                             structLv.name().toBasicString(),
+                                                             expectArgCnt,
+                                                             paraCnt),
+                                                 ip);
+                        }
+
+                        FString opFnName(u8"Operation." + prettyType(structTypeObj) + u8"." + opName);
+
+                        ContextPtr fnCtx = std::make_shared<Context>(
+                            FString(std::format("<Function {}>", opFnName.toBasicString())), ctx);
+
+                        const auto &fillOpFnParas = [this, structType, implMethod, opFnName, fnCtx, ctx, paraCnt](
+                                                        const std::vector<ObjectPtr> &args) {
+                            const Ast::FunctionParameters &paras = implMethod.paras;
+                            for (size_t i = 0; i < paraCnt; ++i)
+                            {
+                                const TypeInfo &paraType =
+                                    actualType(check_unwrap_stres(eval(paras.posParas[i].second, ctx)));
+                                if (paraType != ValueType::Any && paraType != structType)
+                                {
+                                    throw EvaluatorError(
+                                        u8"ParameterTypeError",
+                                        std::format("Invalid op fn parameter type '{}' of `{}`, must be `{}`",
+                                                    paraType.toString().toBasicString(),
+                                                    paras.posParas[i].first.toBasicString(),
+                                                    structType.toString().toBasicString()),
+                                        paras.posParas[i].second);
+                                }
+                                fnCtx->def(paras.posParas[i].first, paraType, AccessModifier::Normal, args[i]);
+                            }
+                        };
+
+                        if (paraCnt == 1)
+                        {
+                            ctx->registerUnaryOperator(structType, op, [=, this](const ObjectPtr &value) -> ExprResult {
+                                fillOpFnParas({value});
+                                return executeFunction(Function(opFnName,
+                                                                implMethod.paras, // parameters
+                                                                structType,       // return type --> struct type
+                                                                implMethod.body,  // body
+                                                                ctx               // closure context
+                                                                ),
+                                                       Ast::FunctionCallArgs{.argv = {value}},
+                                                       fnCtx);
+                            });
+                        }
+                        else
+                        {
+                            ctx->registerBinaryOperator(
+                                structType, op, [=, this](const ObjectPtr &lhs, const ObjectPtr &rhs) {
+                                    fillOpFnParas({lhs, rhs});
+                                    return executeFunction(Function(opFnName,
+                                                                    implMethod.paras, // parameters
+                                                                    structType,       // return type --> struct type
+                                                                    implMethod.body,  // body
+                                                                    ctx               // closure context
+                                                                    ),
+                                                           Ast::FunctionCallArgs{.argv = {lhs, rhs}},
+                                                           fnCtx);
+                                });
+                        }
+                    }
+                    return StatementResult::normal();
+                }
+
+                InterfaceType &interface = interfaceObj->as<InterfaceType>();
+
+                // ===== interface implementation validation =====
+                ImplRecord record{interfaceType, structType, {}};
+
+                std::unordered_map<FString, Ast::InterfaceMethod> ifaceMethods;
+                for (auto &m : interface.methods)
+                {
+                    if (ifaceMethods.contains(m.name))
+                    {
+                        throw EvaluatorError(u8"InterfaceDuplicateMethodError",
+                                             std::format("Interface '{}' has duplicate method '{}'",
+                                                         interfaceType.toString().toBasicString(),
+                                                         m.name.toBasicString()),
+                                             ip);
+                    }
+                    ifaceMethods[m.name] = m;
+                }
+
+                std::unordered_set<FString> implemented;
+
+                for (auto &implMethod : implementMethods)
+                {
+                    const FString &name = implMethod.name;
+
+                    // ---- redundant impl ----
+                    if (!ifaceMethods.contains(name))
+                    {
+                        throw EvaluatorError(u8"RedundantImplementationError",
+                                             std::format("Struct '{}' implements extra method '{}' "
+                                                         "which is not required by interface '{}'",
+                                                         structType.toString().toBasicString(),
+                                                         name.toBasicString(),
+                                                         interfaceType.toString().toBasicString()),
+                                             ip);
+                    }
+
+                    if (implemented.contains(name))
+                    {
+                        throw EvaluatorError(u8"DuplicateImplementMethodError",
+                                             std::format("Duplicate implement method '{}'", name.toBasicString()),
+                                             ip);
+                    }
+
+                    auto &ifMethod = ifaceMethods[name];
+
+                    // ---- signature check ----
+                    if (!isInterfaceSignatureMatch(implMethod, ifMethod))
+                    {
+                        throw EvaluatorError(u8"InterfaceSignatureMismatch",
+                                             std::format("Interface method '{}({})' signature mismatch with "
+                                                         "implementation '{}({})'",
+                                                         ifMethod.name.toBasicString(),
+                                                         ifMethod.paras.toString().toBasicString(),
+                                                         implMethod.name.toBasicString(),
+                                                         implMethod.paras.toString().toBasicString()),
+                                             ip);
+                    }
+
+                    if (ctx->hasMethodImplemented(structType, name))
+                    {
+                        throw EvaluatorError(u8"DuplicateImplementMethodError",
+                                             std::format("Method '{}' already implemented by another interface "
+                                                         "for struct '{}'",
+                                                         name.toBasicString(),
+                                                         structType.toString().toBasicString()),
+                                             ip);
+                    }
+
+                    implemented.insert(name);
+
+                    ObjectPtr returnTypeValue = check_unwrap_stres(eval(ifMethod.returnType, ctx));
+
+                    record.implMethods[name] =
+                        Function(implMethod.name, implMethod.paras, actualType(returnTypeValue), implMethod.body, ctx);
+                }
+
+                for (auto &m : interface.methods)
+                {
+                    if (implemented.contains(m.name)) continue;
+
+                    if (m.hasDefaultBody()) continue;
+
+                    throw EvaluatorError(u8"MissingImplementationError",
+                                         std::format("Struct '{}' does not implement required interface method '{}' "
+                                                     "and interface '{}' provides no default implementation",
+                                                     structType.toString().toBasicString(),
+                                                     m.name.toBasicString(),
+                                                     interfaceType.toString().toBasicString()),
+                                         ip);
+                }
+
+                ctx->setImplRecord(structType, interfaceType, record);
+                return StatementResult::normal();
+            }
+
+            case IfSt: {
+                auto ifSt = std::static_pointer_cast<Ast::IfSt>(stmt);
+                ObjectPtr condVal = check_unwrap_stres(eval(ifSt->condition, ctx));
+                if (condVal->getTypeInfo() != ValueType::Bool)
+                {
+                    throw EvaluatorError(
+                        u8"TypeError",
+                        std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
+                        ifSt->condition);
+                }
+                if (condVal->as<ValueType::BoolClass>()) { return evalBlockStatement(ifSt->body, ctx); }
+                // else
+                for (const auto &elif : ifSt->elifs)
+                {
+                    ObjectPtr elifCondVal = check_unwrap_stres(eval(elif->condition, ctx));
+                    if (elifCondVal->getTypeInfo() != ValueType::Bool)
+                    {
+                        throw EvaluatorError(
+                            u8"TypeError",
+                            std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
+                            ifSt->condition);
+                    }
+                    if (elifCondVal->as<ValueType::BoolClass>()) { return evalBlockStatement(elif->body, ctx); }
+                }
+                if (ifSt->els) { return evalBlockStatement(ifSt->els->body, ctx); }
+                return StatementResult::normal();
+            };
+            case WhileSt: {
+                auto whileSt = std::static_pointer_cast<Ast::WhileSt>(stmt);
+                while (true)
+                {
+                    ObjectPtr condVal = check_unwrap_stres(eval(whileSt->condition, ctx));
+                    if (condVal->getTypeInfo() != ValueType::Bool)
+                    {
+                        throw EvaluatorError(
+                            u8"TypeError",
+                            std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
+                            whileSt->condition);
+                    }
+                    if (!condVal->as<ValueType::BoolClass>()) { break; }
+                    ContextPtr loopContext = std::make_shared<Context>(
+                        FString(std::format("<While {}:{}>", whileSt->getAAI().line, whileSt->getAAI().column)),
+                        ctx); // every loop has its own context
+                    StatementResult sr = evalBlockStatement(whileSt->body, loopContext);
+                    if (sr.shouldReturn()) { return sr; }
+                    if (sr.shouldBreak()) { break; }
+                    if (sr.shouldContinue()) { continue; }
+                }
+                return StatementResult::normal();
+            };
+            case ForSt: {
+                auto forSt = std::static_pointer_cast<Ast::ForSt>(stmt);
+                ContextPtr loopContext = std::make_shared<Context>(
+                    FString(std::format("<For {}:{}>", forSt->getAAI().line, forSt->getAAI().column)),
+                    ctx); // for loop has its own context
+
+                evalStatement(forSt->initSt,
+                              loopContext); // ignore init statement result
+                size_t iteration = 0;
+
+                while (true) // use while loop to simulate for loop, cause we
+                             // need to check condition type every iteration
+                {
+                    ObjectPtr condVal = check_unwrap_stres(eval(forSt->condition, loopContext));
+                    if (condVal->getTypeInfo() != ValueType::Bool)
+                    {
+                        throw EvaluatorError(
+                            u8"TypeError",
+                            std::format("Condition must be boolean, but got '{}'", prettyType(condVal).toBasicString()),
+                            forSt->condition);
+                    }
+                    if (!condVal->as<ValueType::BoolClass>()) { break; }
+                    iteration++;
+                    ContextPtr iterationContext = std::make_shared<Context>(
+                        FString(std::format(
+                            "<For {}:{}, Iteration {}>", forSt->getAAI().line, forSt->getAAI().column, iteration)),
+                        loopContext); // every loop has its own context
+                    StatementResult sr = evalBlockStatement(forSt->body, iterationContext);
+                    if (sr.shouldReturn()) { return sr; }
+                    if (sr.shouldBreak()) { break; }
+                    if (sr.shouldContinue())
+                    {
+                        // continue to next iteration
+                        continue;
+                    }
+                    evalStatement(forSt->incrementSt,
+                                  loopContext); // ignore increment statement result
+                }
+                return StatementResult::normal();
+            }
+
+            case TrySt: {
+                auto tryst = std::static_pointer_cast<Ast::TrySt>(stmt);
+
+                ContextPtr tryCtx = std::make_shared<Context>(
+                    FString(std::format("<Try at {}:{}>", tryst->getAAI().line, tryst->getAAI().column)), ctx);
+                StatementResult sr = StatementResult::normal();
+                bool crashed = false;
+                for (auto &stmt : tryst->body->stmts)
+                {
+                    sr = evalStatement(stmt, tryCtx); // eval in try context
+                    if (sr.isError())
+                    {
+                        crashed = true;
+                        break;
+                    }
+                }
+                bool catched = false;
+                for (auto &cat : tryst->catches)
+                {
+                    const FString &errVarName = cat.errVarName;
+                    TypeInfo errVarType = (cat.hasType ? TypeInfo(cat.errVarType) : ValueType::Any);
+                    if (isTypeMatch(errVarType, sr.result, ctx))
+                    {
+                        ContextPtr catchCtx = std::make_shared<Context>(
+                            FString(
+                                std::format("<Catch at {}:{}>", cat.body->getAAI().line, cat.body->getAAI().column)),
+                            ctx);
+                        catchCtx->def(errVarName, errVarType, AccessModifier::Normal, sr.result);
+                        sr = evalBlockStatement(cat.body, catchCtx);
+                        catched = true;
+                        break;
+                    }
+                }
+                if (!catched && crashed)
+                {
+                    throw EvaluatorError(u8"UncaughtExceptionError",
+                                         std::format("Uncaught exception: {}", sr.result->toString().toBasicString()),
+                                         tryst);
+                }
+                if (tryst->finallyBlock) { sr = evalBlockStatement(tryst->finallyBlock, ctx); }
+                return sr;
+            }
+
+            case ThrowSt: {
+                auto ts = std::static_pointer_cast<Ast::ThrowSt>(stmt);
+
+                ObjectPtr value = check_unwrap_stres(eval(ts->value, ctx));
+                if (value->is<ValueType::NullClass>())
+                {
+                    throw EvaluatorError(u8"TypeError", u8"Why did you throw a null?", ts);
+                }
+                return StatementResult::errorFlow(value);
+            }
+
+            case ReturnSt: {
+                auto returnSt = std::static_pointer_cast<Ast::ReturnSt>(stmt);
+
+                ObjectPtr returnValue = Object::getNullInstance(); // default is null
+                if (returnSt->retValue) returnValue = check_unwrap_stres(eval(returnSt->retValue, ctx));
+                return StatementResult::returnFlow(returnValue);
+            }
+
+            case BreakSt: {
+                if (!ctx->parent)
+                {
+                    throw EvaluatorError(u8"BreakOutsideLoopError", u8"`break` statement outside loop", stmt);
+                }
+                if (!ctx->isInLoopContext())
+                {
+                    throw EvaluatorError(u8"BreakOutsideLoopError", u8"`break` statement outside loop", stmt);
+                }
+                return StatementResult::breakFlow();
+            }
+
+            case ContinueSt: {
+                if (!ctx->parent)
+                {
+                    throw EvaluatorError(u8"ContinueOutsideLoopError", u8"`continue` statement outside loop", stmt);
+                }
+                if (!ctx->isInLoopContext())
+                {
+                    throw EvaluatorError(u8"ContinueOutsideLoopError", u8"`continue` statement outside loop", stmt);
+                }
+                return StatementResult::continueFlow();
+            }
+
+            case ExpressionStmt: {
+                auto exprStmt = std::static_pointer_cast<Ast::ExpressionStmtAst>(stmt);
+                return check_unwrap_stres(eval(exprStmt->exp, ctx));
+            }
+
+            case BlockStatement: {
+                auto block = std::static_pointer_cast<Ast::BlockStatementAst>(stmt);
+
+                ContextPtr blockCtx = std::make_shared<Context>(
+                    FString(std::format("<Block at {}:{}>", block->getAAI().line, block->getAAI().column)), ctx);
+                return evalBlockStatement(block, blockCtx);
+            }
+
+            default:
+                throw RuntimeError(
+                    FString(std::format("Feature stmt {} unsupported yet", magic_enum::enum_name(stmt->getType()))));
+        }
+    }
+}; // namespace Fig

src/Evaluator/Core/EvalTernary.cpp

@@ -0,0 +1,21 @@
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+#include <Evaluator/Core/ExprResult.hpp>
+
+namespace Fig
+{
+
+    ExprResult Evaluator::evalTernary(Ast::TernaryExpr te, ContextPtr ctx)
+    {
+        RvObject condVal = check_unwrap(eval(te->condition, ctx));
+        if (condVal->getTypeInfo() != ValueType::Bool)
+        {
+            throw EvaluatorError(
+                u8"TypeError",
+                std::format("Condition must be boolean, got '{}'", prettyType(condVal).toBasicString()),
+                te->condition);
+        }
+        ValueType::BoolClass cond = condVal->as<ValueType::BoolClass>();
+        return (cond ? eval(te->valueT, ctx) : eval(te->valueF, ctx));
+    }
+};

src/Evaluator/Core/EvalUnary.cpp

@@ -0,0 +1,48 @@
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+#include <Evaluator/Core/ExprResult.hpp>
+
+namespace Fig
+{
+    ExprResult Evaluator::evalUnary(Ast::UnaryExpr un, ContextPtr ctx)
+    {
+        using Ast::Operator;
+        Operator op = un->op;
+        Ast::Expression exp = un->exp;
+        ObjectPtr value = check_unwrap(eval(exp, ctx));
+
+        const auto &tryInvokeOverloadFn = [ctx, op](const ObjectPtr &rhs, const std::function<ExprResult()> &rollback) {
+            if (rhs->is<StructInstance>())
+            {
+                // 运算符重载
+                const TypeInfo &type = actualType(rhs);
+                if (ctx->hasOperatorImplemented(type, op))
+                {
+                    const auto &fnOpt = ctx->getUnaryOperatorFn(type, op);
+                    return (*fnOpt)(rhs);
+                }
+            }
+            return rollback();
+        };
+
+        switch (op)
+        {
+            case Operator::Not: {
+                return tryInvokeOverloadFn(value, [value]() { return std::make_shared<Object>(!(*value)); });
+            }
+            case Operator::Subtract: {
+                return tryInvokeOverloadFn(value, [value]() { return std::make_shared<Object>(-(*value)); });
+            }
+            case Operator::BitNot: {
+                return tryInvokeOverloadFn(value, [value]() { return std::make_shared<Object>(bit_not(*value)); });
+            }
+            default: {
+                throw EvaluatorError(u8"UnsupportedOpError",
+                                     std::format("Unsupported op '{}' for unary expression", magic_enum::enum_name(op)),
+                                     un);
+            }
+        }
+    }
+}; // namespace Fig

src/Evaluator/Core/ExprResult.cpp

@@ -0,0 +1,19 @@
+#include <Evaluator/Core/ExprResult.hpp>
+#include <Evaluator/Core/StatementResult.hpp>
+
+namespace Fig
+{
+    StatementResult ExprResult::toStatementResult() const
+    {
+        if (isError())
+        {
+            if (isResultLv())
+            {
+                return StatementResult::errorFlow(std::get<LvObject>(result).get());
+            }
+            return StatementResult::errorFlow(std::get<RvObject>(result));
+        }
+        if (isResultLv()) { return StatementResult::normal(std::get<LvObject>(result).get()); }
+        return StatementResult::normal(std::get<RvObject>(result));
+    }
+};

src/Evaluator/Core/ExprResult.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <Core/fig_string.hpp>
+#include <Evaluator/Value/value_forward.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+
+#include <variant>
+#include <cassert>
+
+namespace Fig
+{
+    struct StatementResult;
+    struct ExprResult
+    {
+        std::variant<LvObject, RvObject> result;
+        enum class Flow
+        {
+            Normal,
+            Error,
+        } flow;
+
+        ExprResult(ObjectPtr _result, Flow _flow = Flow::Normal) : result(_result), flow(_flow) {}
+        ExprResult(const LvObject &_result, Flow _flow = Flow::Normal) : result(_result), flow(_flow) {}
+
+        static ExprResult normal(ObjectPtr _result) { return ExprResult(_result); }
+        static ExprResult normal(const LvObject &_result) { return ExprResult(_result); }
+
+        static ExprResult error(ObjectPtr _result) { return ExprResult(_result, Flow::Error); }
+        static ExprResult error(const LvObject &_result) { return ExprResult(_result, Flow::Error); }
+
+        bool isNormal() const { return flow == Flow::Normal; }
+
+        bool isError() const { return flow == Flow::Error; }
+
+        bool isResultLv() const { return std::holds_alternative<LvObject>(result); }
+
+        ObjectPtr &unwrap()
+        {
+            if (!isNormal()) { assert(false && "unwrap abnormal ExprResult!"); }
+            return std::get<RvObject>(result);
+        }
+
+        const ObjectPtr &unwrap() const
+        {
+            if (!isNormal()) { assert(false && "unwrap abnormal ExprResult!"); }
+            return std::get<RvObject>(result);
+        }
+
+        const LvObject &unwrap_lv() const { return std::get<LvObject>(result); }
+
+        StatementResult toStatementResult() const;
+    };
+#define check_unwrap(expr)                                                                                             \
+    ({                                                                                                                 \
+        auto _r = (expr);                                                                                              \
+        if (_r.isError()) return _r;                                                                                   \
+        _r.unwrap();                                                                                                   \
+    })
+#define check_unwrap_lv(expr)                                                                                          \
+    ({                                                                                                                 \
+        auto _r = (expr);                                                                                              \
+        if (_r.isError()) return _r;                                                                                   \
+        _r.unwrap_lv();                                                                                                \
+    })
+#define check_unwrap_stres(expr)                                                                                       \
+    ({                                                                                                                 \
+        auto _r = (expr);                                                                                              \
+        if (_r.isError()) return _r.toStatementResult();                                                               \
+        _r.unwrap();                                                                                                   \
+    })
+
+}; // namespace Fig

src/Evaluator/Core/ResolveModulePath.cpp

@@ -0,0 +1,114 @@
+#include <Core/executablePath.hpp>
+
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+
+    std::filesystem::path Evaluator::resolveModulePath(const std::vector<FString> &pathVec)
+    {
+        namespace fs = std::filesystem;
+
+        static const std::vector<fs::path> defaultLibraryPath{"Library", "Library/fpm"};
+
+        std::vector<fs::path> pathToFind(defaultLibraryPath);
+
+        fs::path interpreterPath = getExecutablePath().parent_path();
+
+        for (fs::path &p : pathToFind)
+        {
+            p = interpreterPath / p; // 相对路径 -> 绝对路径
+        }
+
+        pathToFind.insert(
+            pathToFind.begin(),
+            fs::path(this->sourcePath.toBasicString()).parent_path()); // first search module at the source file path
+
+        fs::path path;
+
+        /*
+        Example:
+            import comp.config;
+        */
+
+        const FString &modPathStrTop = pathVec.at(0);
+        fs::path modPath;
+
+        bool found = false;
+        for (auto &parentFolder : pathToFind)
+        {
+            modPath = parentFolder / FString(modPathStrTop + u8".fig").toBasicString();
+            if (fs::exists(modPath))
+            {
+                path = modPath;
+                found = true;
+                break;
+            }
+            else
+            {
+                modPath = parentFolder / modPathStrTop.toBasicString();
+                if (fs::is_directory(modPath)) // comp is a directory
+                {
+                    modPath = modPath / FString(modPathStrTop + u8".fig").toBasicString();
+                    /*
+                        if module name is a directory, we require [module
+                       name].fig at the directory
+                    */
+                    if (!fs::exists(modPath))
+                    {
+                        throw RuntimeError(FString(std::format("requires module file, {}\\{}",
+                                                               modPathStrTop.toBasicString(),
+                                                               FString(modPathStrTop + u8".fig").toBasicString())));
+                    }
+                    found = true;
+                    path = modPath;
+                    break;
+                }
+            }
+        }
+
+        if (!found)
+            throw RuntimeError(FString(std::format("Could not find module `{}`", modPathStrTop.toBasicString())));
+
+        bool found2 = false;
+
+        for (size_t i = 1; i < pathVec.size(); ++i) // has next module
+        {
+            const FString &next = pathVec.at(i);
+            modPath = modPath.parent_path(); // get the folder
+            modPath = modPath / FString(next + u8".fig").toBasicString();
+            if (fs::exists(modPath))
+            {
+                if (i != pathVec.size() - 1)
+                    throw RuntimeError(FString(std::format(
+                        "expects {} as parent directory and find next module, but got a file", next.toBasicString())));
+                // it's the last module
+                found2 = true;
+                path = modPath;
+                break;
+            }
+            // `next` is a folder
+            modPath = modPath.parent_path() / next.toBasicString();
+            if (!fs::exists(modPath))
+                throw RuntimeError(FString(std::format("Could not find module `{}`", next.toBasicString())));
+            if (i == pathVec.size() - 1)
+            {
+                // `next` is the last module
+                modPath = modPath / FString(next + u8".fig").toBasicString();
+                if (!fs::exists(modPath))
+                {
+                    throw RuntimeError(FString(std::format(
+                        "expects {} as parent directory and find next module, but got a file", next.toBasicString())));
+                }
+                found2 = true;
+                path = modPath;
+            }
+        }
+
+        if (!found2 && !fs::exists(modPath))
+            throw RuntimeError(FString(std::format("Could not find module `{}`", pathVec.end()->toBasicString())));
+
+        return path;
+    }
+};

src/Evaluator/Core/StatementResult.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Core/fig_string.hpp>
+#include <Evaluator/Value/value.hpp>
+
+namespace Fig
+{
+    struct StatementResult
+    {
+        ObjectPtr result;
+        enum class Flow
+        {
+            Normal,
+            Return,
+            Break,
+            Continue,
+            Error
+        } flow;
+
+        StatementResult(ObjectPtr val, Flow f = Flow::Normal) : result(val), flow(f) {}
+
+        static StatementResult normal(ObjectPtr val = Object::getNullInstance())
+        {
+            return StatementResult(val, Flow::Normal);
+        }
+        static StatementResult returnFlow(ObjectPtr val) { return StatementResult(val, Flow::Return); }
+        static StatementResult breakFlow() { return StatementResult(Object::getNullInstance(), Flow::Break); }
+        static StatementResult continueFlow() { return StatementResult(Object::getNullInstance(), Flow::Continue); }
+        static StatementResult errorFlow(ObjectPtr val) { return StatementResult(val, Flow::Error); }
+
+        bool isNormal() const { return flow == Flow::Normal; }
+        bool shouldReturn() const { return flow == Flow::Return; }
+        bool shouldBreak() const { return flow == Flow::Break; }
+        bool shouldContinue() const { return flow == Flow::Continue; }
+        bool isError() const { return flow == Flow::Error; }
+    };
+};

src/Evaluator/Value/IntPool.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <Evaluator/Value/value.hpp>
+#include <Core/fig_string.hpp>
+#include <Evaluator/Value/value_forward.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <array>
+#include <memory>
+
+namespace Fig
+{
+    class IntPool
+    {
+    private:
+        static constexpr ValueType::IntClass CACHE_MIN = -128;
+        static constexpr ValueType::IntClass CACHE_MAX = 127;
+
+        std::array<ObjectPtr, CACHE_MAX - CACHE_MIN + 1> cache;
+
+    public:
+        IntPool()
+        {
+            for (ValueType::IntClass i = CACHE_MIN; i <= CACHE_MAX; ++i)
+            {
+                cache[i - CACHE_MIN] = std::make_shared<Object>(i);
+            }
+        }
+        ObjectPtr createInt(ValueType::IntClass val) const
+        {
+            if (val >= CACHE_MIN && val <= CACHE_MAX) { return cache[val - CACHE_MIN]; }
+            return std::make_shared<Object>(val);
+        }
+        Object createIntCopy(ValueType::IntClass val) const
+        {
+            if (val >= CACHE_MIN && val <= CACHE_MAX) { return *cache[val - CACHE_MIN]; }
+            return Object(val);
+        }
+
+        static const IntPool &getInstance()
+        {
+            static IntPool pool;
+            return pool;
+        }
+    };
+}; // namespace Fig

src/Evaluator/Value/LvObject.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <Value/VariableSlot.hpp>
-#include <Value/value.hpp>
+#include <Evaluator/Value/VariableSlot.hpp>
+#include <Evaluator/Value/value.hpp>
 
 namespace Fig
 {
@@ -87,7 +87,7 @@ namespace Fig
                             std::format("Variable `{}` expects type `{}`, but got '{}'",
                                         s->name.toBasicString(),
                                         s->declaredType.toString().toBasicString(),
-                                        v->getTypeInfo().toString().toBasicString())));
+                                        prettyType(v).toBasicString())));
                 }
                 if (isAccessConst(s->am))
                 {

src/Evaluator/Value/Type.hpp

@@ -2,6 +2,7 @@
 
 #include <Core/fig_string.hpp>
 
+#include <unordered_set>
 #include <variant>
 #include <map>
 
@@ -13,44 +14,32 @@ namespace Fig
     private:
         size_t id;
 
+        std::map<FString, size_t> &getTypeMap()
+        {
+            static std::map<FString, size_t> typeMap;
+            return typeMap;
+        }
+
     public:
         friend class TypeInfoHash;
 
         FString name;
 
-        FString toString() const
-        {
-            return name;
-        }
+        FString toString() const { return name; }
 
-        static std::map<FString, size_t> typeMap;
-
-        static size_t getID(FString _name)
-        {
-            return typeMap.at(_name);
-        }
-        size_t getInstanceID() const
-        {
-            return id;
-        }
+        size_t getInstanceID() const { return id; }
 
         TypeInfo();
         explicit TypeInfo(const FString &_name, bool reg = false);
         TypeInfo(const TypeInfo &other) = default;
 
-        bool operator==(const TypeInfo &other) const
-        {
-            return id == other.id;
-        }
+        bool operator==(const TypeInfo &other) const { return id == other.id; }
     };
-    
+
     class TypeInfoHash
     {
     public:
-        std::size_t operator()(const TypeInfo &ti) const
-        {
-            return std::hash<size_t>{}(ti.id);
-        }
+        std::size_t operator()(const TypeInfo &ti) const { return std::hash<size_t>{}(ti.id); }
     };
 
     // class Value;
@@ -75,18 +64,32 @@ namespace Fig
         using BoolClass = bool;
         using NullClass = std::monostate;
         using StringClass = FString;
+
+        inline bool isTypeBuiltin(const TypeInfo &type)
+        {
+            static const std::unordered_set<TypeInfo, TypeInfoHash> builtinTypes{Any,
+                                                                                 Null,
+                                                                                 Int,
+                                                                                 String,
+                                                                                 Bool,
+                                                                                 Double,
+                                                                                 Function,
+                                                                                 StructType,
+                                                                                 StructInstance,
+                                                                                 List,
+                                                                                 Map,
+                                                                                 Module,
+                                                                                 InterfaceType};
+            return builtinTypes.contains(type);
+        }
     }; // namespace ValueType
 }; // namespace Fig
 
-
 namespace std
 {
     template <>
     struct hash<Fig::TypeInfo>
     {
-        size_t operator()(const Fig::TypeInfo &t)
-        {
-            return std::hash<size_t>{}(t.getInstanceID());
-        }
+        size_t operator()(const Fig::TypeInfo &t) { return std::hash<size_t>{}(t.getInstanceID()); }
     };
-};
+}; // namespace std

src/Evaluator/Value/VariableSlot.hpp

@@ -3,12 +3,13 @@
 
 #include <Ast/AccessModifier.hpp>
 #include <Core/fig_string.hpp>
-#include <Value/Type.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Value/value_forward.hpp>
+
 #include <memory>
 namespace Fig
 {
-    class Object;
-    using ObjectPtr = std::shared_ptr<Object>;
+
     struct VariableSlot
     {
         FString name;

src/Evaluator/Value/function.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Ast/functionParameters.hpp>
-#include <Context/context_forward.hpp>
+#include <Evaluator/Context/context_forward.hpp>
 
 #include <atomic>
 #include <functional>
@@ -11,51 +11,94 @@
 namespace Fig
 {
     class Object;
+
     class Function
     {
     public:
         std::size_t id;
-        Ast::FunctionParameters paras;
-        TypeInfo retType;
-        Ast::BlockStatement body;
+        FString name;
+
+        enum FnType
+        {
+            Normal,
+            Builtin,
+            MemberType
+        } type;
+
+        union
+        {
+            struct
+            {
+                Ast::FunctionParameters paras;
+                TypeInfo retType;
+
+                Ast::BlockStatement body;
+            };
+            std::function<std::shared_ptr<Object>(const std::vector<std::shared_ptr<Object>> &)> builtin;
+            std::function<std::shared_ptr<Object>(std::shared_ptr<Object>,
+                                                  const std::vector<std::shared_ptr<Object>> &)>
+                mtFn;
+        };
 
-        bool isBuiltin = false;
-        std::function<std::shared_ptr<Object>(const std::vector<std::shared_ptr<Object>> &)> builtin;
         int builtinParamCount = -1;
 
         std::shared_ptr<Context> closureContext;
 
         // ===== Constructors =====
-        Function() :
-            id(nextId()) {}
+        Function() : id(nextId()), type(Normal)
+        {
+            // 需要初始化 union ！
+            new (&paras) Ast::FunctionParameters();
+            new (&retType) TypeInfo();
+            new (&body) Ast::BlockStatement();
+        }
 
-        Function(Ast::FunctionParameters _paras, TypeInfo _retType, Ast::BlockStatement _body, ContextPtr _closureContext) :
+        Function(const FString &_name,
+                 Ast::FunctionParameters _paras,
+                 TypeInfo _retType,
+                 Ast::BlockStatement _body,
+                 ContextPtr _closureContext) :
             id(nextId()), // 分配唯一 ID
+            name(_name),
             paras(std::move(_paras)),
             retType(std::move(_retType)),
             body(std::move(_body)),
             closureContext(std::move(_closureContext))
         {
+            type = Normal;
         }
 
-        Function(std::function<std::shared_ptr<Object>(const std::vector<std::shared_ptr<Object>> &)> fn, int argc) :
-            id(nextId()), isBuiltin(true), builtin(fn), builtinParamCount(argc) {}
+        Function(const FString &_name, std::function<std::shared_ptr<Object>(const std::vector<std::shared_ptr<Object>> &)> fn, int argc) :
+            id(nextId()), name(_name), type(Builtin), builtin(fn), builtinParamCount(argc)
+        {
+            type = Builtin;
+        }
+
+        Function(const FString &_name, std::function<std::shared_ptr<Object>(std::shared_ptr<Object>,
+                                                       const std::vector<std::shared_ptr<Object>> &)> fn,
+                 int argc) :
+            id(nextId()), name(_name), type(MemberType), mtFn(fn), builtinParamCount(argc)
+        {
+            type = MemberType;
+        }
 
         // ===== Copy / Move =====
-        Function(const Function &other) = default;
-        Function(Function &&) noexcept = default;
-        Function &operator=(const Function &) = default;
-        Function &operator=(Function &&) noexcept = default;
+        Function(const Function &other) { copyFrom(other); }
+        Function &operator=(const Function &other)
+        {
+            if (this != &other)
+            {
+                destroy();
+                copyFrom(other);
+            }
+            return *this;
+        };
+
+        ~Function() { destroy(); }
 
         // ===== Comparison =====
-        bool operator==(const Function &other) const noexcept
-        {
-            return id == other.id;
-        }
-        bool operator!=(const Function &other) const noexcept
-        {
-            return !(*this == other);
-        }
+        bool operator==(const Function &other) const noexcept { return id == other.id; }
+        bool operator!=(const Function &other) const noexcept { return !(*this == other); }
 
     private:
         static std::size_t nextId()
@@ -63,5 +106,44 @@ namespace Fig
             static std::atomic<std::size_t> counter{1};
             return counter++;
         }
+        void destroy()
+        {
+            switch (type)
+            {
+                case Normal:
+                    paras.~FunctionParameters();
+                    retType.~TypeInfo();
+                    body.~shared_ptr();
+                    break;
+                case Builtin: builtin.~function(); break;
+                case MemberType: mtFn.~function(); break;
+            }
+        }
+
+        void copyFrom(const Function &other)
+        {
+            name = other.name;
+            type = other.type;
+            id = nextId(); // 每个复制都生成新的ID
+            builtinParamCount = other.builtinParamCount;
+            closureContext = other.closureContext;
+
+            switch (type)
+            {
+                case Normal:
+                    new (&paras) Ast::FunctionParameters(other.paras);
+                    new (&retType) TypeInfo(other.retType);
+                    new (&body) Ast::BlockStatement(other.body);
+                    break;
+                case Builtin:
+                    new (&builtin) std::function<std::shared_ptr<Object>(const std::vector<std::shared_ptr<Object>> &)>(
+                        other.builtin);
+                    break;
+                case MemberType:
+                    new (&mtFn) std::function<std::shared_ptr<Object>(
+                        std::shared_ptr<Object>, const std::vector<std::shared_ptr<Object>> &)>(other.mtFn);
+                    break;
+            }
+        }
     };
 } // namespace Fig

src/Evaluator/Value/interface.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Ast/Statements/InterfaceDefSt.hpp>
-#include <Value/Type.hpp>
+#include <Evaluator/Value/Type.hpp>
 
 #include <vector>
 

src/Evaluator/Value/module.hpp

@@ -2,7 +2,7 @@
 
 #include <Core/fig_string.hpp>
 
-#include <Context/context_forward.hpp>
+#include <Evaluator/Context/context_forward.hpp>
 
 namespace Fig
 {

src/Evaluator/Value/structInstance.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <Context/context_forward.hpp>
-#include <Value/Type.hpp>
+#include <Evaluator/Context/context_forward.hpp>
+#include <Evaluator/Value/Type.hpp>
 
 namespace Fig
 {

src/Evaluator/Value/structType.hpp

@@ -3,9 +3,9 @@
 #include <Core/fig_string.hpp>
 #include <Ast/Statements/StructDefSt.hpp>
 
-#include <Value/Type.hpp>
+#include <Evaluator/Value/Type.hpp>
 
-#include <Context/context_forward.hpp>
+#include <Evaluator/Context/context_forward.hpp>
 #include <atomic>
 #include <vector>
 

src/Evaluator/Value/value.cpp

@@ -1,12 +1,14 @@
-#include <Value/Type.hpp>
-#include <Value/value.hpp>
-#include <Context/context.hpp>
+#include <Evaluator/Value/interface.hpp>
+#include <Evaluator/Value/structType.hpp>
+#include <Evaluator/Value/value_forward.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Context/context.hpp>
 
 // #include <iostream>
 
 namespace Fig
 {
-    std::map<FString, size_t> TypeInfo::typeMap = {};
 
     TypeInfo::TypeInfo() : // only allow use in evaluate time !! <---- dynamic type system requirement
         id(1), name(FString(u8"Any"))
@@ -19,19 +21,17 @@ namespace Fig
         // std::cerr << "TypeInfo constructor called for type name: " << name.toBasicString() << "\n";
         if (reg)
         {
-            typeMap[name] = ++id_count;
+            getTypeMap()[name] = ++id_count;
             id = id_count;
         }
         else
         {
-            if (!typeMap.contains(_name))
+            if (!getTypeMap().contains(_name))
             {
-                throw RuntimeError(FString(std::format(
-                    "No type named '{}'",
-                    _name.toBasicString())));
+                throw RuntimeError(FString(std::format("No type named '{}'", _name.toBasicString())));
                 // *this = ValueType::String;
             }
-            id = typeMap.at(name); // may throw
+            id = getTypeMap().at(name); // may throw
         }
     }
 
@@ -41,10 +41,7 @@ namespace Fig
             ObjectPtr value = key.value;
             const TypeInfo &type = value->getTypeInfo();
 
-            if (type == ValueType::Int)
-            {
-                return std::hash<ValueType::IntClass>{}(value->as<ValueType::IntClass>());
-            }
+            if (type == ValueType::Int) { return std::hash<ValueType::IntClass>{}(value->as<ValueType::IntClass>()); }
             if (type == ValueType::Double)
             {
                 return std::hash<ValueType::DoubleClass>{}(value->as<ValueType::DoubleClass>());
@@ -61,10 +58,7 @@ namespace Fig
             {
                 auto HashFields = [](std::vector<Field> fields) {
                     size_t r = 0;
-                    for (auto &f : fields)
-                    {
-                        r += std::hash<Field>{}(f);
-                    }
+                    for (auto &f : fields) { r += std::hash<Field>{}(f); }
                     return r;
                 };
                 const StructType &st = value->as<StructType>();
@@ -73,19 +67,35 @@ namespace Fig
             if (type == ValueType::StructInstance)
             {
                 const StructInstance &si = value->as<StructInstance>();
-                return std::hash<TypeInfo>{}(si.parentType) + std::hash<uint64_t>{}(reinterpret_cast<uint64_t>(std::addressof(*si.localContext)));
+                return std::hash<TypeInfo>{}(si.parentType)
+                       + std::hash<uint64_t>{}(reinterpret_cast<uint64_t>(std::addressof(*si.localContext)));
             }
             assert(false);
             throw ""; // ignore warning
         }
     }
 
-    FString prettyType(std::shared_ptr<const Object> obj)
+    TypeInfo actualType(std::shared_ptr<const Object> obj)
     {
         auto t = obj->getTypeInfo();
-        if (t == ValueType::StructInstance)
-            return obj->as<StructInstance>().parentType.toString();
-        return t.toString();
+        
+        // dispatch builtin struct types (like Int{}, List{} e.g...)
+        if (t == ValueType::StructType)
+        {
+            return obj->as<StructType>().type;
+        }
+
+        if (t == ValueType::InterfaceType)
+        {
+            return obj->as<InterfaceType>().type;
+        }
+
+        if (t == ValueType::StructInstance) return obj->as<StructInstance>().parentType;
+        return t;
+    }
+    FString prettyType(std::shared_ptr<const Object> obj)
+    {
+        return actualType(obj).toString();
     }
 
     const TypeInfo ValueType::Any(FString(u8"Any"), true);                       // id: 1
@@ -102,8 +112,6 @@ namespace Fig
     const TypeInfo ValueType::Module(FString(u8"Module"), true);                 // id: 12
     const TypeInfo ValueType::InterfaceType(FString(u8"InterfaceType"), true);   // id: 13
 
-
-
     bool implements(const TypeInfo &structType, const TypeInfo &interfaceType, ContextPtr ctx)
     {
         return ctx->hasImplRegisted(structType, interfaceType);
@@ -111,28 +119,25 @@ namespace Fig
 
     bool isTypeMatch(const TypeInfo &expected, ObjectPtr obj, ContextPtr ctx)
     {
-        if (expected == ValueType::Any)
-            return true;
+        if (expected == ValueType::Any) return true;
 
         TypeInfo actual = obj->getTypeInfo();
 
-        if (obj->is<StructInstance>())
+        if (obj->is<StructType>())
+        {
+            const StructType &t = obj->as<StructType>();
+            if (expected == t.type) // the StructType typeinfo
+            {
+                return true;
+            }
+        }
+        else if (obj->is<StructInstance>())
         {
             const StructInstance &si = obj->as<StructInstance>();
-            if (si.parentType == expected)
-            {
-                return true;
-            }
-            if (implements(si.parentType, expected, ctx))
-            {
-                return true;
-            }
-            return false;
-        }
-        else
-        {
-            return expected == actual;
+            if (si.parentType == expected) { return true; }
+            if (implements(si.parentType, expected, ctx)) { return true; }
         }
+        return expected == actual;
     }
 
 } // namespace Fig

src/Evaluator/Value/value.hpp

@@ -1,13 +1,18 @@
 #pragma once
-#include <Value/function.hpp>
-#include <Value/interface.hpp>
-#include <Value/structType.hpp>
-#include <Value/structInstance.hpp>
-#include <Value/Type.hpp>
-#include <Value/valueError.hpp>
-#include <Value/module.hpp>
+#include <Core/fig_string.hpp>
+#include <Evaluator/Value/function.hpp>
+#include <Evaluator/Value/interface.hpp>
+#include <Evaluator/Value/structType.hpp>
+#include <Evaluator/Value/structInstance.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Value/valueError.hpp>
+#include <Evaluator/Value/module.hpp>
+#include <Evaluator/Value/value_forward.hpp>
 
+#include <cassert>
+// #include <iostream>
 #include <memory>
+#include <unordered_set>
 #include <variant>
 #include <cmath>
 #include <string>
@@ -31,10 +36,13 @@ namespace Fig
             static_cast<ValueType::DoubleClass>(std::numeric_limits<ValueType::IntClass>::min());
         return d > intMaxAsDouble || d < intMinAsDouble;
     }
-    class Object;
-    using ObjectPtr = std::shared_ptr<Object>;
 
+    inline bool nearlyEqual(ValueType::DoubleClass l, ValueType::DoubleClass r, ValueType::DoubleClass epsilon = 1e-9)
+    {
+        return std::abs(l - r) < epsilon;
+    }
 
+    TypeInfo actualType(std::shared_ptr<const Object> obj);
     FString prettyType(std::shared_ptr<const Object> obj);
 
     bool operator==(const Object &, const Object &);
@@ -42,26 +50,18 @@ namespace Fig
     struct Element
     {
         ObjectPtr value;
-        Element(ObjectPtr _value) :
-            value(_value) {}
-        
-        bool operator==(const Element &other) const
-        {
-            return *value == *other.value;
-        }
+        Element(ObjectPtr _value) : value(_value) {}
 
-        void deepCopy(const Element &e)
-        {
-            value = std::make_shared<Object>(*e.value);
-        }
+        bool operator==(const Element &other) const { return *value == *other.value; }
+
+        void deepCopy(const Element &e) { value = std::make_shared<Object>(*e.value); }
     };
     using List = std::vector<Element>;
 
     struct ValueKey
     {
         ObjectPtr value;
-        ValueKey(ObjectPtr _value) :
-            value(_value) {}
+        ValueKey(ObjectPtr _value) : value(_value) {}
 
         void deepCopy(const ValueKey &vk) { value = std::make_shared<Object>(*vk.value); }
     };
@@ -75,231 +75,235 @@ namespace Fig
     bool isTypeMatch(const TypeInfo &, ObjectPtr, ContextPtr);
     bool implements(const TypeInfo &, const TypeInfo &, ContextPtr);
 
+    using BuiltinTypeMemberFn = std::function<ObjectPtr(ObjectPtr, std::vector<ObjectPtr>)>;
+
     class Object : public std::enable_shared_from_this<Object>
     {
     public:
-        using VariantType = std::variant<
-            ValueType::NullClass,
-            ValueType::IntClass,
-            ValueType::DoubleClass,
-            ValueType::StringClass,
-            ValueType::BoolClass,
-            Function,
-            StructType,
-            StructInstance,
-            List,
-            Map,
-            Module,
-            InterfaceType>;
+        using VariantType = std::variant<ValueType::NullClass,
+                                         ValueType::IntClass,
+                                         ValueType::DoubleClass,
+                                         ValueType::StringClass,
+                                         ValueType::BoolClass,
+                                         Function,
+                                         StructType,
+                                         StructInstance,
+                                         List,
+                                         Map,
+                                         Module,
+                                         InterfaceType>;
+
+        static std::unordered_map<TypeInfo, std::unordered_map<FString, BuiltinTypeMemberFn>, TypeInfoHash>
+        getMemberTypeFunctions()
+        {
+            static const std::unordered_map<TypeInfo, std::unordered_map<FString, BuiltinTypeMemberFn>, TypeInfoHash>
+                memberTypeFunctions{
+                    {ValueType::Null, {}},
+                    {ValueType::Int, {}},
+                    {ValueType::Double, {}},
+                    {ValueType::String,
+                     {
+                         {u8"length",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 0)
+                                  throw RuntimeError(
+                                      FString(std::format("`length` expects 0 arguments, {} got", args.size())));
+                              const FString &str = object->as<ValueType::StringClass>();
+                              return std::make_shared<Object>(static_cast<ValueType::IntClass>(str.length()));
+                          }},
+                         {u8"replace",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 2)
+                                  throw RuntimeError(
+                                      FString(std::format("`replace` expects 2 arguments, {} got", args.size())));
+                              FString &str = object->as<ValueType::StringClass>();
+                              ObjectPtr arg1 = args[0];
+                              ObjectPtr arg2 = args[1];
+                              if (!arg1->is<ValueType::IntClass>())
+                              {
+                                  throw RuntimeError(FString("`replace` arg 1 expects type Int"));
+                              }
+                              if (!arg2->is<ValueType::StringClass>())
+                              {
+                                  throw RuntimeError(FString("`replace` arg 2 expects type String"));
+                              }
+                              str.realReplace(arg1->as<ValueType::IntClass>(), arg2->as<ValueType::StringClass>());
+                              return Object::getNullInstance();
+                          }},
+                         {u8"erase",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 2)
+                                  throw RuntimeError(
+                                      FString(std::format("`erase` expects 2 arguments, {} got", args.size())));
+                              FString &str = object->as<ValueType::StringClass>();
+                              ObjectPtr arg1 = args[0];
+                              ObjectPtr arg2 = args[1];
+                              if (!arg1->is<ValueType::IntClass>())
+                              {
+                                  throw RuntimeError(FString("`erase` arg 1 expects type Int"));
+                              }
+                              if (!arg2->is<ValueType::IntClass>())
+                              {
+                                  throw RuntimeError(FString("`erase` arg 2 expects type Int"));
+                              }
+                              ValueType::IntClass index = arg1->as<ValueType::IntClass>();
+                              ValueType::IntClass n = arg2->as<ValueType::IntClass>();
+                              if (index < 0 || n < 0)
+                              {
+                                  throw RuntimeError(FString("`erase`: index and n must greater or equal to 0"));
+                              }
+                              if (index + n > str.length())
+                              {
+                                  throw RuntimeError(FString("`erase`: length is not long enough to erase"));
+                              }
+                              str.realErase(arg1->as<ValueType::IntClass>(), arg2->as<ValueType::IntClass>());
+                              return Object::getNullInstance();
+                          }},
+                         {u8"insert",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 2)
+                                  throw RuntimeError(
+                                      FString(std::format("`insert` expects 2 arguments, {} got", args.size())));
+                              FString &str = object->as<ValueType::StringClass>();
+                              ObjectPtr arg1 = args[0];
+                              ObjectPtr arg2 = args[1];
+                              if (!arg1->is<ValueType::IntClass>())
+                              {
+                                  throw RuntimeError(FString("`insert` arg 1 expects type Int"));
+                              }
+                              if (!arg2->is<ValueType::StringClass>())
+                              {
+                                  throw RuntimeError(FString("`insert` arg 2 expects type String"));
+                              }
+                              str.realInsert(arg1->as<ValueType::IntClass>(), arg2->as<ValueType::StringClass>());
+                              return Object::getNullInstance();
+                          }},
+                     }},
+                    {ValueType::Function, {}},
+                    {ValueType::StructType, {}},
+                    {ValueType::StructInstance, {}},
+                    {ValueType::List,
+                     {
+                         {u8"length",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 0)
+                                  throw RuntimeError(
+                                      FString(std::format("`length` expects 0 arguments, {} got", args.size())));
+                              const List &list = object->as<List>();
+                              return std::make_shared<Object>(static_cast<ValueType::IntClass>(list.size()));
+                          }},
+                         {u8"get",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 1)
+                                  throw RuntimeError(
+                                      FString(std::format("`get` expects 1 arguments, {} got", args.size())));
+                              ObjectPtr arg = args[0];
+                              if (arg->getTypeInfo() != ValueType::Int)
+                                  throw RuntimeError(
+                                      FString(std::format("`get` argument 1 expects Int, {} got",
+                                                          arg->getTypeInfo().toString().toBasicString())));
+                              ValueType::IntClass i = arg->as<ValueType::IntClass>();
+                              const List &list = object->as<List>();
+                              if (i >= list.size()) return Object::getNullInstance();
+                              return list[i].value;
+                          }},
+                         {u8"push",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 1)
+                                  throw RuntimeError(
+                                      FString(std::format("`push` expects 1 arguments, {} got", args.size())));
+                              ObjectPtr arg = args[0];
+                              List &list = object->as<List>();
+                              list.push_back(arg);
+                              return Object::getNullInstance();
+                          }},
+                     }},
+                    {ValueType::Map,
+                     {
+                         {u8"get",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 1)
+                                  throw RuntimeError(
+                                      FString(std::format("`get` expects 1 arguments, {} got", args.size())));
+                              ObjectPtr index = args[0];
+                              const Map &map = object->as<Map>();
+                              if (!map.contains(index)) return Object::getNullInstance();
+                              return map.at(index);
+                          }},
+                         {u8"contains",
+                          [](ObjectPtr object, std::vector<ObjectPtr> args) -> ObjectPtr {
+                              if (args.size() != 1)
+                                  throw RuntimeError(
+                                      FString(std::format("`contains` expects 1 arguments, {} got", args.size())));
+                              ObjectPtr index = args[0];
+                              const Map &map = object->as<Map>();
+                              return std::make_shared<Object>(map.contains(index));
+                          }},
+                     }},
+                    {ValueType::Module, {}},
+                    {ValueType::InterfaceType, {}},
+                };
+            return memberTypeFunctions;
+        }
+
+        static std::unordered_map<TypeInfo, std::unordered_map<FString, int>, TypeInfoHash>
+        getMemberTypeFunctionsParas()
+        {
+            static const std::unordered_map<TypeInfo, std::unordered_map<FString, int>, TypeInfoHash>
+                memberTypeFunctionsParas{
+                    {ValueType::Null, {}},
+                    {ValueType::Int, {}},
+                    {ValueType::Double, {}},
+                    {ValueType::String,
+                     {
+                         {u8"length", 0},
+                         {u8"replace", 2},
+                         {u8"erase", 2},
+                         {u8"insert", 2},
+                     }},
+                    {ValueType::Function, {}},
+                    {ValueType::StructType, {}},
+                    {ValueType::StructInstance, {}},
+                    {ValueType::List, {{u8"length", 0}, {u8"get", 1}, {u8"push", 1}}},
+                    {ValueType::Map,
+                     {
+                         {u8"get", 1},
+                         {u8"contains", 1},
+                     }},
+                    {ValueType::Module, {}},
+                    {ValueType::InterfaceType, {}},
+                };
+            return memberTypeFunctionsParas;
+        }
 
-        std::unordered_map<TypeInfo,
-                           std::unordered_map<FString,
-                                              std::function<ObjectPtr(std::vector<ObjectPtr>)>>,
-                           TypeInfoHash>
-            memberTypeFunctions{
-                {ValueType::Null, {}},
-                {ValueType::Int, {}},
-                {ValueType::Double, {}},
-                {ValueType::String, {
-                                        {u8"length", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                             if (args.size() != 0)
-                                                 throw RuntimeError(FString(
-                                                     std::format("`length` expects 0 arguments, {} got", args.size())));
-                                             const FString &str = as<ValueType::StringClass>();
-                                             return std::make_shared<Object>(static_cast<ValueType::IntClass>(str.length()));
-                                         }},
-                                        {u8"replace", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                             if (args.size() != 2)
-                                                 throw RuntimeError(FString(
-                                                     std::format("`replace` expects 2 arguments, {} got", args.size())));
-                                             FString &str = as<ValueType::StringClass>();
-                                             ObjectPtr arg1 = args[0];
-                                             ObjectPtr arg2 = args[1];
-                                             if (!arg1->is<ValueType::IntClass>())
-                                             {
-                                                 throw RuntimeError(FString(
-                                                     "`replace` arg 1 expects type Int"));
-                                             }
-                                             if (!arg2->is<ValueType::StringClass>())
-                                             {
-                                                 throw RuntimeError(FString(
-                                                     "`replace` arg 2 expects type String"));
-                                             }
-                                             str.realReplace(arg1->as<ValueType::IntClass>(), arg2->as<ValueType::StringClass>());
-                                             return Object::getNullInstance();
-                                         }},
-                                        {u8"erase", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                             if (args.size() != 2)
-                                                 throw RuntimeError(FString(
-                                                     std::format("`erase` expects 2 arguments, {} got", args.size())));
-                                             FString &str = as<ValueType::StringClass>();
-                                             ObjectPtr arg1 = args[0];
-                                             ObjectPtr arg2 = args[1];
-                                             if (!arg1->is<ValueType::IntClass>())
-                                             {
-                                                 throw RuntimeError(FString(
-                                                     "`erase` arg 1 expects type Int"));
-                                             }
-                                             if (!arg2->is<ValueType::IntClass>())
-                                             {
-                                                 throw RuntimeError(FString(
-                                                     "`erase` arg 2 expects type Int"));
-                                             }
-                                             ValueType::IntClass index = arg1->as<ValueType::IntClass>();
-                                             ValueType::IntClass n = arg2->as<ValueType::IntClass>();
-                                             if (index < 0 || n < 0)
-                                             {
-                                                 throw RuntimeError(FString("`erase`: index and n must greater or equal to 0"));
-                                             }
-                                             if (index + n > str.length())
-                                             {
-                                                 throw RuntimeError(FString("`erase`: length is not long enough to erase"));
-                                             }
-                                             str.realErase(arg1->as<ValueType::IntClass>(), arg2->as<ValueType::IntClass>());
-                                             return Object::getNullInstance();
-                                         }},
-                                        {u8"insert", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                             if (args.size() != 2)
-                                                 throw RuntimeError(FString(
-                                                     std::format("`insert` expects 2 arguments, {} got", args.size())));
-                                             FString &str = as<ValueType::StringClass>();
-                                             ObjectPtr arg1 = args[0];
-                                             ObjectPtr arg2 = args[1];
-                                             if (!arg1->is<ValueType::IntClass>())
-                                             {
-                                                 throw RuntimeError(FString(
-                                                     "`insert` arg 1 expects type Int"));
-                                             }
-                                             if (!arg2->is<ValueType::StringClass>())
-                                             {
-                                                 throw RuntimeError(FString(
-                                                     "`insert` arg 2 expects type String"));
-                                             }
-                                             str.realInsert(arg1->as<ValueType::IntClass>(), arg2->as<ValueType::StringClass>());
-                                             return Object::getNullInstance();
-                                         }},
-                                    }},
-                {ValueType::Function, {}},
-                {ValueType::StructType, {}},
-                {ValueType::StructInstance, {}},
-                {ValueType::List, {
-                                      {u8"length", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                           if (args.size() != 0)
-                                               throw RuntimeError(FString(
-                                                   std::format("`length` expects 0 arguments, {} got", args.size())));
-                                           const List &list = as<List>();
-                                           return std::make_shared<Object>(static_cast<ValueType::IntClass>(list.size()));
-                                       }},
-                                      {u8"get", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                           if (args.size() != 1)
-                                               throw RuntimeError(FString(
-                                                   std::format("`get` expects 1 arguments, {} got", args.size())));
-                                           ObjectPtr arg = args[0];
-                                           if (arg->getTypeInfo() != ValueType::Int)
-                                               throw RuntimeError(FString(
-                                                   std::format("`get` argument 1 expects Int, {} got", arg->getTypeInfo().toString().toBasicString())));
-                                           ValueType::IntClass i = arg->as<ValueType::IntClass>();
-                                           const List &list = as<List>();
-                                           if (i >= list.size())
-                                               return Object::getNullInstance();
-                                           return list[i].value;
-                                       }},
-                                      {u8"push", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                           if (args.size() != 1)
-                                               throw RuntimeError(FString(
-                                                   std::format("`push` expects 1 arguments, {} got", args.size())));
-                                           ObjectPtr arg = args[0];
-                                           List &list = as<List>();
-                                           list.push_back(arg);
-                                           return Object::getNullInstance();
-                                       }},
-                                  }},
-                {ValueType::Map, {
-                                     {u8"get", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                          if (args.size() != 1)
-                                              throw RuntimeError(FString(
-                                                  std::format("`get` expects 1 arguments, {} got", args.size())));
-                                          ObjectPtr index = args[0];
-                                          const Map &map = as<Map>();
-                                          if (!map.contains(index))
-                                              return Object::getNullInstance();
-                                          return map.at(index);
-                                      }},
-                                     {u8"contains", [this](std::vector<ObjectPtr> args) -> ObjectPtr {
-                                          if (args.size() != 1)
-                                              throw RuntimeError(FString(
-                                                  std::format("`contains` expects 1 arguments, {} got", args.size())));
-                                          ObjectPtr index = args[0];
-                                          const Map &map = as<Map>();
-                                          return std::make_shared<Object>(
-                                              map.contains(index));
-                                      }},
-                                 }},
-                {ValueType::Module, {}},
-                {ValueType::InterfaceType, {}},
-            };
-        std::unordered_map<TypeInfo, std::unordered_map<FString, int>, TypeInfoHash> memberTypeFunctionsParas{
-            {ValueType::Null, {}},
-            {ValueType::Int, {}},
-            {ValueType::Double, {}},
-            {ValueType::String, {
-                                    {u8"length", 0},
-                                    {u8"replace", 2},
-                                    {u8"erase", 2},
-                                    {u8"insert", 2},
-                                }},
-            {ValueType::Function, {}},
-            {ValueType::StructType, {}},
-            {ValueType::StructInstance, {}},
-            {ValueType::List, {{u8"length", 0}, {u8"get", 1}, {u8"push", 1}}},
-            {ValueType::Map, {
-                                 {u8"get", 1},
-                                 {u8"contains", 1},
-                             }},
-            {ValueType::Module, {}},
-            {ValueType::InterfaceType, {}},
-        };
         bool hasMemberFunction(const FString &name) const
         {
-            return memberTypeFunctions.at(getTypeInfo()).contains(name);
+            return getMemberTypeFunctions().at(getTypeInfo()).contains(name);
         }
-        std::function<ObjectPtr(std::vector<ObjectPtr>)> getMemberFunction(const FString &name) const
+        BuiltinTypeMemberFn getMemberFunction(const FString &name) const
         {
-            return memberTypeFunctions.at(getTypeInfo()).at(name);
+            return getMemberTypeFunctions().at(getTypeInfo()).at(name);
         }
         int getMemberFunctionParaCount(const FString &name) const
         {
-            return memberTypeFunctionsParas.at(getTypeInfo()).at(name);
+            return getMemberTypeFunctionsParas().at(getTypeInfo()).at(name);
         }
 
         VariantType data;
 
-        Object() :
-            data(ValueType::NullClass{}) {}
-        Object(const ValueType::NullClass &n) :
-            data(n) {}
-        Object(const ValueType::IntClass &i) :
-            data(i) {}
-        explicit Object(const ValueType::DoubleClass &d) :
-            data(d) {}
-        Object(const ValueType::StringClass &s) :
-            data(s) {}
-        Object(const ValueType::BoolClass &b) :
-            data(b) {}
-        Object(const Function &f) :
-            data(f) {}
-        Object(const StructType &s) :
-            data(s) {}
-        Object(const StructInstance &s) :
-            data(s) {}
-        Object(const List &l) :
-            data(l) {}
-        Object(const Map &m) :
-            data(m) {}
-        Object(const Module &m) :
-            data(m) {}
-        Object(const InterfaceType &i) :
-            data(i) {}
+        Object() : data(ValueType::NullClass{}) {}
+        Object(const ValueType::NullClass &n) : data(n) {}
+        Object(const ValueType::IntClass &i) : data(i) {}
+        explicit Object(const ValueType::DoubleClass &d) : data(d) {}
+        Object(const ValueType::StringClass &s) : data(s) {}
+        Object(const ValueType::BoolClass &b) : data(b) {}
+        Object(const Function &f) : data(f) {}
+        Object(const StructType &s) : data(s) {}
+        Object(const StructInstance &s) : data(s) {}
+        Object(const List &l) : data(l) {}
+        Object(const Map &m) : data(m) {}
+        Object(const Module &m) : data(m) {}
+        Object(const InterfaceType &i) : data(i) {}
 
         Object(const Object &) = default;
         Object(Object &&) noexcept = default;
@@ -360,49 +364,50 @@ namespace Fig
 
         TypeInfo getTypeInfo() const
         {
-            return std::visit([](auto &&val) -> TypeInfo {
-                using T = std::decay_t<decltype(val)>;
+            return std::visit(
+                [](auto &&val) -> TypeInfo {
+                    using T = std::decay_t<decltype(val)>;
 
-                if constexpr (std::is_same_v<T, ValueType::NullClass>)
-                    return ValueType::Null;
+                    if constexpr (std::is_same_v<T, ValueType::NullClass>)
+                        return ValueType::Null;
 
-                else if constexpr (std::is_same_v<T, ValueType::IntClass>)
-                    return ValueType::Int;
+                    else if constexpr (std::is_same_v<T, ValueType::IntClass>)
+                        return ValueType::Int;
 
-                else if constexpr (std::is_same_v<T, ValueType::DoubleClass>)
-                    return ValueType::Double;
+                    else if constexpr (std::is_same_v<T, ValueType::DoubleClass>)
+                        return ValueType::Double;
 
-                else if constexpr (std::is_same_v<T, ValueType::StringClass>)
-                    return ValueType::String;
+                    else if constexpr (std::is_same_v<T, ValueType::StringClass>)
+                        return ValueType::String;
 
-                else if constexpr (std::is_same_v<T, ValueType::BoolClass>)
-                    return ValueType::Bool;
+                    else if constexpr (std::is_same_v<T, ValueType::BoolClass>)
+                        return ValueType::Bool;
 
-                else if constexpr (std::is_same_v<T, Function>)
-                    return ValueType::Function;
+                    else if constexpr (std::is_same_v<T, Function>)
+                        return ValueType::Function;
 
-                else if constexpr (std::is_same_v<T, StructType>)
-                    return ValueType::StructType;
+                    else if constexpr (std::is_same_v<T, StructType>)
+                        return ValueType::StructType;
 
-                else if constexpr (std::is_same_v<T, StructInstance>)
-                    return ValueType::StructInstance;
+                    else if constexpr (std::is_same_v<T, StructInstance>)
+                        return ValueType::StructInstance;
 
-                else if constexpr (std::is_same_v<T, List>)
-                    return ValueType::List;
+                    else if constexpr (std::is_same_v<T, List>)
+                        return ValueType::List;
 
-                else if constexpr (std::is_same_v<T, Map>)
-                    return ValueType::Map;
+                    else if constexpr (std::is_same_v<T, Map>)
+                        return ValueType::Map;
 
-                else if constexpr (std::is_same_v<T, Module>)
-                    return ValueType::Module;
+                    else if constexpr (std::is_same_v<T, Module>)
+                        return ValueType::Module;
 
-                else if constexpr (std::is_same_v<T, InterfaceType>)
-                    return ValueType::InterfaceType;
+                    else if constexpr (std::is_same_v<T, InterfaceType>)
+                        return ValueType::InterfaceType;
 
-                else
-                    return ValueType::Any;
-            },
-                              data);
+                    else
+                        return ValueType::Any;
+                },
+                data);
         }
 
         bool isNull() const { return is<ValueType::NullClass>(); }
@@ -424,7 +429,7 @@ namespace Fig
             return toString();
         }
 
-        FString toString() const
+        FString toString(std::unordered_set<const Object *> &visited) const
         {
             if (is<ValueType::NullClass>()) return FString(u8"null");
             if (is<ValueType::IntClass>()) return FString(std::to_string(as<ValueType::IntClass>()));
@@ -432,9 +437,8 @@ namespace Fig
             if (is<ValueType::StringClass>()) return FString(u8"\"" + as<ValueType::StringClass>() + u8"\"");
             if (is<ValueType::BoolClass>()) return as<ValueType::BoolClass>() ? FString(u8"true") : FString(u8"false");
             if (is<Function>())
-                return FString(std::format("<Function '{}' at {:p}>",
-                                           as<Function>().id,
-                                           static_cast<const void *>(&as<Function>())));
+                return FString(std::format(
+                    "<Function '{}' at {:p}>", as<Function>().id, static_cast<const void *>(&as<Function>())));
             if (is<StructType>())
                 return FString(std::format("<StructType '{}' at {:p}>",
                                            as<StructType>().type.toString().toBasicString(),
@@ -445,14 +449,16 @@ namespace Fig
                                            static_cast<const void *>(&as<StructInstance>())));
             if (is<List>())
             {
+                if (visited.contains(this)) { return u8"[...]"; }
+                visited.insert(this);
+
                 FString output(u8"[");
                 const List &list = as<List>();
                 bool first_flag = true;
                 for (auto &ele : list)
                 {
-                    if (!first_flag)
-                        output += u8", ";
-                    output += ele.value->toString();
+                    if (!first_flag) output += u8", ";
+                    output += ele.value->toString(visited);
                     first_flag = false;
                 }
                 output += u8"]";
@@ -460,14 +466,16 @@ namespace Fig
             }
             if (is<Map>())
             {
+                if (visited.contains(this)) { return u8"{...}"; }
+                visited.insert(this);
+
                 FString output(u8"{");
                 const Map &map = as<Map>();
                 bool first_flag = true;
                 for (auto &[key, value] : map)
                 {
-                    if (!first_flag)
-                        output += u8", ";
-                    output += key.value->toString() + FString(u8" : ") + value->toString();
+                    if (!first_flag) output += u8", ";
+                    output += key.value->toString(visited) + FString(u8" : ") + value->toString(visited);
                     first_flag = false;
                 }
                 output += u8"}";
@@ -475,24 +483,28 @@ namespace Fig
             }
             if (is<Module>())
             {
-                return FString(std::format(
-                    "<Module '{}' at {:p}>",
-                    as<Module>().name.toBasicString(),
-                    static_cast<const void *>(&as<Module>())));
+                return FString(std::format("<Module '{}' at {:p}>",
+                                           as<Module>().name.toBasicString(),
+                                           static_cast<const void *>(&as<Module>())));
             }
             if (is<InterfaceType>())
             {
-                return FString(std::format(
-                    "<InterfaceType '{}' at {:p}>",
-                    as<InterfaceType>().type.toString().toBasicString(),
-                    static_cast<const void *>(&as<InterfaceType>())));
+                return FString(std::format("<InterfaceType '{}' at {:p}>",
+                                           as<InterfaceType>().type.toString().toBasicString(),
+                                           static_cast<const void *>(&as<InterfaceType>())));
             }
             return FString(u8"<error>");
         }
 
+        FString toString() const
+        {
+            std::unordered_set<const Object *> visited{};
+            return toString(visited);
+        }
+
     private:
-        static std::string makeTypeErrorMessage(const char *prefix, const char *op,
-                                                const Object &lhs, const Object &rhs)
+        static std::string
+        makeTypeErrorMessage(const char *prefix, const char *op, const Object &lhs, const Object &rhs)
         {
             auto lhs_type = lhs.getTypeInfo().name.toBasicString();
             auto rhs_type = rhs.getTypeInfo().name.toBasicString();
@@ -509,8 +521,7 @@ namespace Fig
             {
                 bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
                 auto result = lhs.getNumericValue() + rhs.getNumericValue();
-                if (bothInt && !isNumberExceededIntLimit(result))
-                    return Object(static_cast<ValueType::IntClass>(result));
+                if (bothInt) return Object(static_cast<ValueType::IntClass>(result));
                 return Object(result);
             }
             if (lhs.is<ValueType::StringClass>() && rhs.is<ValueType::StringClass>())
@@ -526,8 +537,7 @@ namespace Fig
             {
                 bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
                 auto result = lhs.getNumericValue() - rhs.getNumericValue();
-                if (bothInt && !isNumberExceededIntLimit(result))
-                    return Object(static_cast<ValueType::IntClass>(result));
+                if (bothInt) return Object(static_cast<ValueType::IntClass>(result));
                 return Object(result);
             }
             throw ValueError(FString(makeTypeErrorMessage("Unsupported operation", "-", lhs, rhs)));
@@ -541,8 +551,14 @@ namespace Fig
             {
                 bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
                 auto result = lhs.getNumericValue() * rhs.getNumericValue();
-                if (bothInt && !isNumberExceededIntLimit(result))
-                    return Object(static_cast<ValueType::IntClass>(result));
+                if (bothInt) return Object(static_cast<ValueType::IntClass>(result));
+                return Object(result);
+            }
+            if (lhs.is<ValueType::StringClass>() && rhs.is<ValueType::IntClass>())
+            {
+                FString result;
+                const FString &l = lhs.as<ValueType::StringClass>();
+                for (size_t i = 0; i < rhs.getNumericValue(); ++i) { result += l; }
                 return Object(result);
             }
             throw ValueError(FString(makeTypeErrorMessage("Unsupported operation", "*", lhs, rhs)));
@@ -555,11 +571,10 @@ namespace Fig
             if (lhs.isNumeric() && rhs.isNumeric())
             {
                 auto rnv = rhs.getNumericValue();
-                if (rnv == 0)
-                    throw ValueError(FString(makeTypeErrorMessage("Division by zero", "/", lhs, rhs)));
+                if (rnv == 0) throw ValueError(FString(makeTypeErrorMessage("Division by zero", "/", lhs, rhs)));
                 // bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
                 auto result = lhs.getNumericValue() / rnv;
-                // if (bothInt && !isNumberExceededIntLimit(result))
+                // if (bothInt)
                 //     return Object(static_cast<ValueType::IntClass>(result));
 
                 // int / int maybe decimals
@@ -573,15 +588,23 @@ namespace Fig
         {
             if (lhs.isNull() || rhs.isNull())
                 throw ValueError(FString(makeTypeErrorMessage("Cannot modulo", "%", lhs, rhs)));
+            if (lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>())
+            {
+                ValueType::IntClass lv = lhs.as<ValueType::IntClass>();
+                ValueType::IntClass rv = lhs.as<ValueType::IntClass>();
+                if (rv == 0) throw ValueError(FString(makeTypeErrorMessage("Modulo by zero", "/", lhs, rhs)));
+
+                ValueType::IntClass q = lv / rv;
+                ValueType::IntClass r = lv % rv;
+                if (r != 0 && ((lv < 0) != (rv < 0))) { q -= 1; }
+                return q;
+            }
+
             if (lhs.isNumeric() && rhs.isNumeric())
             {
                 auto rnv = rhs.getNumericValue();
-                if (rnv == 0)
-                    throw ValueError(FString(makeTypeErrorMessage("Modulo by zero", "/", lhs, rhs)));
-                bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
+                if (rnv == 0) throw ValueError(FString(makeTypeErrorMessage("Modulo by zero", "/", lhs, rhs)));
                 auto result = std::fmod(lhs.getNumericValue(), rnv);
-                if (bothInt && !isNumberExceededIntLimit(result))
-                    return Object(static_cast<ValueType::IntClass>(result));
                 return Object(result);
             }
             throw ValueError(FString(makeTypeErrorMessage("Unsupported operation", "%", lhs, rhs)));
@@ -605,30 +628,36 @@ namespace Fig
         friend Object operator!(const Object &v)
         {
             if (!v.is<ValueType::BoolClass>())
-                throw ValueError(FString(std::format("Logical NOT requires bool: '{}'", v.getTypeInfo().name.toBasicString())));
+                throw ValueError(
+                    FString(std::format("Logical NOT requires bool: '{}'", v.getTypeInfo().name.toBasicString())));
             return Object(!v.as<ValueType::BoolClass>());
         }
 
         friend Object operator-(const Object &v)
         {
-            if (v.isNull())
-                throw ValueError(FString(u8"Unary minus cannot be applied to null"));
-            if (v.is<ValueType::IntClass>())
-                return Object(-v.as<ValueType::IntClass>());
-            if (v.is<ValueType::DoubleClass>())
-                return Object(-v.as<ValueType::DoubleClass>());
-            throw ValueError(FString(std::format("Unary minus requires int or double: '{}'", v.getTypeInfo().name.toBasicString())));
+            if (v.isNull()) throw ValueError(FString(u8"Unary minus cannot be applied to null"));
+            if (v.is<ValueType::IntClass>()) return Object(-v.as<ValueType::IntClass>());
+            if (v.is<ValueType::DoubleClass>()) return Object(-v.as<ValueType::DoubleClass>());
+            throw ValueError(
+                FString(std::format("Unary minus requires int or double: '{}'", v.getTypeInfo().name.toBasicString())));
         }
 
         friend Object operator~(const Object &v)
         {
             if (!v.is<ValueType::IntClass>())
-                throw ValueError(FString(std::format("Bitwise NOT requires int: '{}'", v.getTypeInfo().name.toBasicString())));
+                throw ValueError(
+                    FString(std::format("Bitwise NOT requires int: '{}'", v.getTypeInfo().name.toBasicString())));
             return Object(~v.as<ValueType::IntClass>());
         }
 
         // comparison
-        friend bool operator==(const Object &lhs, const Object &rhs) { return lhs.data == rhs.data; }
+        friend bool operator==(const Object &lhs, const Object &rhs) {
+            if (lhs.isNumeric() && rhs.isNumeric())
+            {
+                return nearlyEqual(lhs.getNumericValue(), rhs.getNumericValue());
+            }
+            return lhs.data == rhs.data; 
+        }
         friend bool operator!=(const Object &lhs, const Object &rhs) { return !(lhs == rhs); }
         friend bool operator<(const Object &lhs, const Object &rhs)
         {
@@ -672,7 +701,8 @@ namespace Fig
         friend Object bit_not(const Object &v)
         {
             if (!v.is<ValueType::IntClass>())
-                throw ValueError(FString(std::format("Bitwise NOT requires int: '{}'", v.getTypeInfo().name.toBasicString())));
+                throw ValueError(
+                    FString(std::format("Bitwise NOT requires int: '{}'", v.getTypeInfo().name.toBasicString())));
             return Object(~v.as<ValueType::IntClass>());
         }
 
@@ -698,15 +728,19 @@ namespace Fig
             {
                 bool bothInt = base.is<ValueType::IntClass>() && exp.is<ValueType::IntClass>();
                 auto result = std::pow(base.getNumericValue(), exp.getNumericValue());
-                if (bothInt && !isNumberExceededIntLimit(result))
-                    return Object(static_cast<ValueType::IntClass>(result));
+                if (bothInt) return Object(static_cast<ValueType::IntClass>(result));
                 return Object(result);
             }
             throw ValueError(FString(makeTypeErrorMessage("Unsupported operation", "**", base, exp)));
         }
     };
 
-    using ObjectPtr = std::shared_ptr<Object>;
+    inline bool isBoolObjectTruthy(ObjectPtr obj)
+    {
+        assert(obj->is<bool>());
+        return obj->as<bool>();
+    }
+
     using RvObject = ObjectPtr;
 
     inline bool operator==(const ValueKey &l, const ValueKey &r)

src/Evaluator/Value/value_forward.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <memory>
+
+namespace Fig
+{
+    class Object;
+
+    using ObjectPtr = std::shared_ptr<Object>;
+}; // namespace Fig

src/Evaluator/evaluator.hpp

@@ -1,61 +1,33 @@
-#include "Ast/Statements/ImplementSt.hpp"
-#include "Ast/Statements/InterfaceDefSt.hpp"
-#include "Value/Type.hpp"
+#pragma once
+#include "Ast/AccessModifier.hpp"
+#include "Ast/Expressions/BinaryExpr.hpp"
+#include "Ast/Expressions/ValueExpr.hpp"
+#include "Ast/Expressions/VarExpr.hpp"
+#include "Ast/Statements/ControlSt.hpp"
+#include "Ast/astBase.hpp"
+#include "Ast/functionParameters.hpp"
+#include "Value/value.hpp"
+#include <Ast/Expressions/FunctionCall.hpp>
+#include <Ast/Expressions/InitExpr.hpp>
+#include <Ast/Statements/ImplementSt.hpp>
+#include <Ast/Statements/InterfaceDefSt.hpp>
+#include <Evaluator/Value/Type.hpp>
 #include <Ast/ast.hpp>
 
-#include <Context/context.hpp>
+#include <Evaluator/Context/context.hpp>
 #include <Error/error.hpp>
 #include <Module/builtins.hpp>
-#include <Value/LvObject.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <cstddef>
 #include <filesystem>
 
+#include <Evaluator/Core/StatementResult.hpp>
+#include <Evaluator/Core/ExprResult.hpp>
+#include <memory>
+#include <source_location>
+
 namespace Fig
 {
-    struct StatementResult
-    {
-        ObjectPtr result;
-        enum class Flow
-        {
-            Normal,
-            Return,
-            Break,
-            Continue,
-            Error
-        } flow;
-
-        StatementResult(ObjectPtr val, Flow f = Flow::Normal) :
-            result(val), flow(f)
-        {
-        }
-
-        static StatementResult normal(ObjectPtr val = Object::getNullInstance())
-        {
-            return StatementResult(val, Flow::Normal);
-        }
-        static StatementResult returnFlow(ObjectPtr val)
-        {
-            return StatementResult(val, Flow::Return);
-        }
-        static StatementResult breakFlow()
-        {
-            return StatementResult(Object::getNullInstance(), Flow::Break);
-        }
-        static StatementResult continueFlow()
-        {
-            return StatementResult(Object::getNullInstance(), Flow::Continue);
-        }
-        static StatementResult errorFlow(ObjectPtr val)
-        {
-            return StatementResult(val, Flow::Error);
-        }
-
-        bool isNormal() const { return flow == Flow::Normal; }
-        bool shouldReturn() const { return flow == Flow::Return; }
-        bool shouldBreak() const { return flow == Flow::Break; }
-        bool shouldContinue() const { return flow == Flow::Continue; }
-        bool isError() const { return flow == Flow::Error; }
-    };
-
     class Evaluator
     {
     private:
@@ -63,11 +35,11 @@ namespace Fig
 
     public:
         FString sourcePath;
+        std::vector<FString> sourceLines;
 
-        void SetSourcePath(const FString &sp)
-        {
-            sourcePath = sp;
-        }
+        void SetSourcePath(const FString &sp) { sourcePath = sp; }
+
+        void SetSourceLines(const std::vector<FString> &sl) { sourceLines = sl; }
 
         void SetGlobalContext(ContextPtr ctx)
         {
@@ -75,59 +47,98 @@ namespace Fig
             global = ctx;
         }
 
-        void CreateGlobalContext()
-        {
-            global = std::make_shared<Context>(
-                FString(u8"<Global>"));
-        }
+        void CreateGlobalContext() { global = std::make_shared<Context>(FString(u8"<Global>")); }
 
         void RegisterBuiltins() // only function
         {
             assert(global != nullptr);
 
-            for (auto &[name, fn] : Builtins::builtinFunctions)
+            for (auto &[name, fn] : Builtins::getBuiltinFunctions())
             {
                 int argc = Builtins::getBuiltinFunctionParamCount(name);
-                Function f(fn, argc);
-                global->def(
-                    name,
-                    ValueType::Function,
-                    AccessModifier::Const,
-                    std::make_shared<Object>(f));
+                Function f(name, fn, argc);
+                global->def(name, ValueType::Function, AccessModifier::Const, std::make_shared<Object>(f));
             }
+
+            global->setImplRecord(
+                Builtins::getTypeErrorStructTypeInfo(),
+                Builtins::getErrorInterfaceTypeInfo(),
+                ImplRecord{
+                    .interfaceType = Builtins::getErrorInterfaceTypeInfo(),
+                    .structType = Builtins::getTypeErrorStructTypeInfo(),
+                    .implMethods = {
+                        {u8"toString",
+                         Function(
+                             u8"toString",
+                             Ast::FunctionParameters{},
+                             ValueType::String,
+                             std::make_shared<Ast::BlockStatementAst>(std::vector<Ast::Statement>(
+                                 {std::make_shared<Ast::ReturnSt>(std::make_shared<Ast::BinaryExprAst>(
+                                     std::make_shared<Ast::ValueExprAst>(std::make_shared<Object>(u8"TypeError: ")),
+                                     Ast::Operator::Add,
+                                     std::make_shared<Ast::FunctionCallExpr>(
+                                         std::make_shared<Ast::VarExprAst>(u8"getErrorMessage"),
+                                         Ast::FunctionArguments{})))})),
+                             nullptr)},
+                        {u8"getErrorClass",
+                         Function(u8"getErrorClass",
+                                  Ast::FunctionParameters{},
+                                  ValueType::String,
+                                  std::make_shared<Ast::BlockStatementAst>(std::vector<Ast::Statement>(
+                                      {std::make_shared<Ast::ReturnSt>(std::make_shared<Ast::ValueExprAst>(
+                                          std::make_shared<Object>(FString(u8"TypeError"))))})),
+                                  nullptr)},
+                        {u8"getErrorMessage",
+                         Function(u8"getErrorMessage",
+                                  Ast::FunctionParameters{},
+                                  ValueType::String,
+                                  std::make_shared<Ast::BlockStatementAst>(std::vector<Ast::Statement>(
+                                      {std::make_shared<Ast::ReturnSt>(std::make_shared<Ast::VarExprAst>(u8"msg"))})),
+                                  nullptr)},
+                    }});
         }
 
         void RegisterBuiltinsValue()
         {
             assert(global != nullptr);
 
-            for (auto &[name, val] : Builtins::builtinValues)
+            for (auto &[name, val] : Builtins::getBuiltinValues())
             {
-                global->def(
-                    name,
-                    val->getTypeInfo(),
-                    AccessModifier::Const,
-                    val);
+                global->def(name, val->getTypeInfo(), AccessModifier::Const, val);
             }
         }
 
         bool isInterfaceSignatureMatch(const Ast::ImplementMethod &, const Ast::InterfaceMethod &);
 
-        /* Left-value eval*/
-        LvObject evalVarExpr(Ast::VarExpr, ContextPtr);
-        LvObject evalMemberExpr(Ast::MemberExpr, ContextPtr); // a.b
-        LvObject evalIndexExpr(Ast::IndexExpr, ContextPtr);   // a[b]
+        ObjectPtr genTypeError(const FString &_msg,
+                               const Ast::AstBase &_ast,
+                               ContextPtr ctx,
+                               std::source_location loc = std::source_location::current())
+        {
+            ContextPtr stCtx = std::make_shared<Context>(u8"<TypeError Instance>");
+            stCtx->def(u8"msg", ValueType::String, AccessModifier::Const, std::make_shared<Object>(_msg));
+            return std::make_shared<Object>(StructInstance(Builtins::getTypeErrorStructTypeInfo(), stCtx));
+        }
 
-        LvObject evalLv(Ast::Expression, ContextPtr); // for access: a.b / index a[b]
+        /* Left-value eval*/
+        ExprResult evalVarExpr(Ast::VarExpr, ContextPtr);       // identifier: a, b, c
+        ExprResult evalMemberExpr(Ast::MemberExpr, ContextPtr); // a.b
+        ExprResult evalIndexExpr(Ast::IndexExpr, ContextPtr);   // a[b]
+
+        ExprResult evalLv(Ast::Expression, ContextPtr); // for access: a.b / index a[b]
 
         /* Right-value eval*/
+        ExprResult evalInitExpr(Ast::InitExpr, ContextPtr);
+        ExprResult evalBinary(Ast::BinaryExpr, ContextPtr);   // normal binary expr: +, -, *....
+        ExprResult evalUnary(Ast::UnaryExpr, ContextPtr);     // unary expr
+        ExprResult evalTernary(Ast::TernaryExpr, ContextPtr); // ternary expr
 
-        RvObject evalBinary(Ast::BinaryExpr, ContextPtr);   // normal binary expr: +, -, *....
-        RvObject evalUnary(Ast::UnaryExpr, ContextPtr);     // unary expr
-        RvObject evalTernary(Ast::TernaryExpr, ContextPtr); // ternary expr
+        ExprResult executeFunction(const Function &fn, const Ast::FunctionCallArgs &, ContextPtr); // fn, fn context
 
-        RvObject evalFunctionCall(const Function &, const Ast::FunctionArguments &, const FString &, ContextPtr); // function call
-        RvObject eval(Ast::Expression, ContextPtr);
+        ExprResult evalFunctionCall(const Ast::FunctionCall &,
+                                    ContextPtr); // function call
+
+        ExprResult eval(Ast::Expression, ContextPtr);
 
         StatementResult evalBlockStatement(Ast::BlockStatement, ContextPtr); // block
         StatementResult evalStatement(Ast::Statement, ContextPtr);           // statement
@@ -139,6 +150,8 @@ namespace Fig
 
         StatementResult Run(std::vector<Ast::AstBase>); // Entry
 
+        void handle_error(const StatementResult &, const Ast::Statement &, const ContextPtr &);
+
         void printStackTrace();
     };
 }; // namespace Fig

src/Evaluator/evaluator_error.hpp

@@ -10,18 +10,31 @@ namespace Fig
     public:
         FString typeName;
         using AddressableError::AddressableError;
-        EvaluatorError(FString _typeName, FString msg, Ast::AstBase ast, std::source_location loc = std::source_location::current())
+        EvaluatorError(FString _typeName,
+                       FString msg,
+                       Ast::AstBase ast,
+                       std::source_location loc = std::source_location::current())
         {
             message = msg;
-            line = ast->getAAI().line;
-            column = ast->getAAI().column;
+
 
             src_loc = std::move(loc);
 
             typeName = std::move(_typeName);
 
+            if (ast != nullptr)
+            {
+                line = ast->getAAI().line;
+                column = ast->getAAI().column;
+                sourcePath = *ast->getAAI().sourcePath;
+                sourceLines = *ast->getAAI().sourceLines;
+            }
+
         }
-        EvaluatorError(FString _typeName, std::string_view msg, Ast::AstBase ast, std::source_location loc = std::source_location::current())
+        EvaluatorError(FString _typeName,
+                       std::string_view msg,
+                       Ast::AstBase ast,
+                       std::source_location loc = std::source_location::current())
         {
             message = FString::fromBasicString(std::string(msg.data()));
             line = ast->getAAI().line;
@@ -30,13 +43,11 @@ namespace Fig
             src_loc = std::move(loc);
 
             typeName = std::move(_typeName);
+
+            sourcePath = *ast->getAAI().sourcePath;
+            sourceLines = *ast->getAAI().sourceLines;
         }
 
-        virtual FString getErrorType() const override
-        {
-            return typeName;
-        }
-
-
+        virtual FString getErrorType() const override { return typeName; }
     };
-};
+}; // namespace Fig

src/IR/IR.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <Core/fig_string.hpp>
+
+#include <vector>
+#include <cstdint>
+namespace Fig::IR
+{
+    using Reg = uint16_t;
+    using Label = uint32_t;
+
+    constexpr Reg INVALID_REG = 0xFFFF;
+
+    enum class Op : uint8_t
+    {
+        // ---- control ----
+        Nop,
+        Jmp,
+        Br, // conditional branch
+        Ret,
+        Call,
+
+        // ---- arithmetic ----
+        Add,
+        Sub,
+        Mul,
+        Div,
+
+        // ---- compare ----
+        Lt,
+        Le,
+        Gt,
+        Ge,
+        Eq,
+
+        // ---- data ----
+        LoadImm, // immediate -> reg
+        Mov,
+    };
+
+    struct Inst
+    {
+        Op op;
+
+        Reg dst; // 结果寄存器
+        Reg a;   // operand a
+        Reg b;   // operand b
+
+        int64_t imm; // immediate / jump offset
+    };
+
+    struct Function
+    {
+        FString name;
+
+        uint16_t paramCount;
+        uint16_t localCount; // 不含参数
+        uint16_t regCount; // param + locals + temps
+
+        std::vector<Inst> code;
+    };
+};

src/IR/IRInterpreter.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <IR/IR.hpp>
+
+#include <cassert>
+
+namespace Fig::IR
+{
+    struct VirtualMachine
+    {
+        std::vector<Function *> functions;
+
+        int64_t execute(Function *fn, const int64_t *args) 
+        {
+            assert(fn != nullptr);
+            std::vector<int64_t> regs(fn->regCount);
+            // load params
+
+            size_t ip = 0;
+
+            while (ip < fn->code.size())
+            {
+                const Inst &ins = fn->code[ip++];
+
+                switch (ins.op)
+                {
+                    case Op::Nop: break;
+
+                    case Op::LoadImm: regs[ins.dst] = ins.imm; break;
+
+                    case Op::Mov: regs[ins.dst] = regs[ins.a]; break;
+
+                    case Op::Add: regs[ins.dst] = regs[ins.a] + regs[ins.b]; break;
+
+                    case Op::Sub: regs[ins.dst] = regs[ins.a] - regs[ins.b]; break;
+
+                    case Op::Mul: regs[ins.dst] = regs[ins.a] * regs[ins.b]; break;
+
+                    case Op::Div: regs[ins.dst] = regs[ins.a] / regs[ins.b]; break;
+
+                    case Op::Lt: regs[ins.dst] = regs[ins.a] < regs[ins.b]; break;
+
+                    case Op::Le: regs[ins.dst] = regs[ins.a] <= regs[ins.b]; break;
+
+                    case Op::Gt: regs[ins.dst] = regs[ins.a] > regs[ins.b]; break;
+
+                    case Op::Ge: regs[ins.dst] = regs[ins.a] >= regs[ins.b]; break;
+
+                    case Op::Eq: regs[ins.dst] = regs[ins.a] == regs[ins.b]; break;
+
+                    case Op::Jmp: ip = static_cast<size_t>(static_cast<int64_t>(ip) + ins.imm); break;
+
+                    case Op::Br:
+                        if (regs[ins.a] == 0) { ip = static_cast<size_t>(static_cast<int64_t>(ip) + ins.imm); }
+                        break;
+
+                    case Op::Call: {
+                        // currently supports 1-arg call via reg a
+                        Function *callee = functions.at(static_cast<size_t>(ins.imm));
+                        int64_t arg0 = regs[ins.a];
+                        int64_t ret = execute(callee, &arg0);
+                        regs[ins.dst] = ret;
+                        break;
+                    }
+
+                    case Op::Ret: return regs[ins.a];
+                }
+            }
+
+            // unreachable normally
+            return 0;
+        }
+    };
+}; // namespace Fig::IR

src/IR/ir_test_main.cpp

@@ -0,0 +1,14 @@
+#include <IR/IRInterpreter.hpp>
+#include <IR/IR.hpp>
+
+
+int main()
+{
+    using namespace Fig;
+    IR::VirtualMachine vm;
+
+    using namespace IR;
+    IR::Inst fib_ir[] = {
+        
+    };
+}

src/Lexer/lexer.cpp

@@ -10,6 +10,10 @@
     #include <iostream> // debug
 #endif
 
+#ifndef SourceInfo
+    #define SourceInfo(ptr) (ptr->sourcePath), (ptr->sourceLines)
+#endif
+
 namespace Fig
 {
 
@@ -62,7 +66,10 @@ namespace Fig
         {FString(u8"["), TokenType::LeftBracket},
         {FString(u8"]"), TokenType::RightBracket},
         {FString(u8"{"), TokenType::LeftBrace},
-        {FString(u8"}"), TokenType::RightBrace}};
+        {FString(u8"}"), TokenType::RightBrace},
+        {FString(u8"?"), TokenType::Question},
+        {FString(u8"!"), TokenType::Not},
+    };
 
     const std::unordered_map<FString, TokenType> Lexer::keyword_map{
         {FString(u8"and"), TokenType::And},
@@ -77,6 +84,7 @@ namespace Fig
         {FString(u8"for"), TokenType::For},
         {FString(u8"if"), TokenType::If},
         {FString(u8"else"), TokenType::Else},
+        {FString(u8"new"), TokenType::New},
         {FString(u8"struct"), TokenType::Struct},
         {FString(u8"interface"), TokenType::Interface},
         {FString(u8"impl"), TokenType::Implement},
@@ -89,6 +97,7 @@ namespace Fig
         {FString(u8"catch"), TokenType::Catch},
         {FString(u8"throw"), TokenType::Throw},
         {FString(u8"Finally"), TokenType::Finally},
+        {FString(u8"as"), TokenType::As},
 
         // {FString(u8"Null"), TokenType::TypeNull},
         // {FString(u8"Int"), TokenType::TypeInt},
@@ -163,7 +172,7 @@ namespace Fig
             {
                 if (it.isEnd())
                 {
-                    error = SyntaxError(u8"Unterminated FString", this->line, it.column());
+                    error = SyntaxError(u8"Unterminated FString", this->line, it.column(), SourceInfo(this));
                     return IllegalTok;
                 }
                 next();
@@ -200,12 +209,11 @@ namespace Fig
                 }
                 else
                 {
-                    error = SyntaxError(FString(
-                                            std::format(
-                                                "Unsupported escape character: {}",
-                                                FString(ec.getString()).toBasicString())),
+                    error = SyntaxError(FString(std::format("Unsupported escape character: {}",
+                                                            FString(ec.getString()).toBasicString())),
                                         this->line,
-                                        it.column());
+                                        it.column(),
+                                        SourceInfo(this));
                     return IllegalTok;
                 }
             }
@@ -217,7 +225,7 @@ namespace Fig
         }
         if (unterminated)
         {
-            error = SyntaxError(u8"Unterminated FString", this->line, str_start_col);
+            error = SyntaxError(u8"Unterminated FString", this->line, str_start_col, SourceInfo(this));
             return IllegalTok;
         }
         return Token(str, TokenType::LiteralString);
@@ -244,7 +252,7 @@ namespace Fig
         }
         if (unterminated)
         {
-            error = SyntaxError(u8"Unterminated FString", this->line, str_start_col);
+            error = SyntaxError(u8"Unterminated FString", this->line, str_start_col, SourceInfo(this));
             return IllegalTok;
         }
         return Token(str, TokenType::LiteralString);
@@ -275,7 +283,7 @@ namespace Fig
             {
                 if (it.isEnd())
                 {
-                    error = SyntaxError(u8"Unterminated FString", this->line, it.column());
+                    error = SyntaxError(u8"Unterminated FString", this->line, it.column(), SourceInfo(this));
                     return IllegalTok;
                 }
                 next();
@@ -317,12 +325,11 @@ namespace Fig
                 }
                 else
                 {
-                    error = SyntaxError(FString(
-                                            std::format(
-                                                "Unsupported escape character: {}",
-                                                FString(ec.getString()).toBasicString())),
+                    error = SyntaxError(FString(std::format("Unsupported escape character: {}",
+                                                            FString(ec.getString()).toBasicString())),
                                         this->line,
-                                        it.column());
+                                        it.column(),
+                                        SourceInfo(this));
                     return IllegalTok;
                 }
             }
@@ -334,7 +341,7 @@ namespace Fig
         }
         if (unterminated)
         {
-            error = SyntaxError(u8"Unterminated FString", this->line, str_start_col);
+            error = SyntaxError(u8"Unterminated FString", this->line, str_start_col, SourceInfo(this));
             return IllegalTok;
         }
         return Token(str, TokenType::LiteralString);
@@ -378,8 +385,10 @@ namespace Fig
 
         if (numStr.ends_with(U'e'))
         {
-            error = SyntaxError(
-                FString(std::format("Illegal number literal: {}", numStr.toBasicString())), this->line, it.column());
+            error = SyntaxError(FString(std::format("Illegal number literal: {}", numStr.toBasicString())),
+                                this->line,
+                                it.column(),
+                                SourceInfo(this));
             return IllegalTok;
         }
 
@@ -395,8 +404,10 @@ namespace Fig
 
         if (!hasDigit)
         {
-            error = SyntaxError(
-                FString(std::format("Illegal number literal: {}", numStr.toBasicString())), this->line, it.column());
+            error = SyntaxError(FString(std::format("Illegal number literal: {}", numStr.toBasicString())),
+                                this->line,
+                                it.column(),
+                                SourceInfo(this));
             return IllegalTok;
         }
 
@@ -407,14 +418,16 @@ namespace Fig
             {
                 error = SyntaxError(FString(std::format("Illegal number literal: {}", numStr.toBasicString())),
                                     this->line,
-                                    it.column());
+                                    it.column(),
+                                    SourceInfo(this));
                 return IllegalTok;
             }
             if (ePos + 1 >= numStr.length())
             {
                 error = SyntaxError(FString(std::format("Illegal number literal: {}", numStr.toBasicString())),
                                     this->line,
-                                    it.column());
+                                    it.column(),
+                                    SourceInfo(this));
                 return IllegalTok;
             }
             bool hasDigitAfterE = false;
@@ -427,7 +440,8 @@ namespace Fig
                     {
                         error = SyntaxError(FString(std::format("Illegal number literal: {}", numStr.toBasicString())),
                                             this->line,
-                                            it.column());
+                                            it.column(),
+                                            SourceInfo(this));
                         return IllegalTok;
                     }
                     continue;
@@ -438,7 +452,8 @@ namespace Fig
                 {
                     error = SyntaxError(FString(std::format("Illegal number literal: {}", numStr.toBasicString())),
                                         this->line,
-                                        it.column());
+                                        it.column(),
+                                        SourceInfo(this));
                     return IllegalTok;
                 }
             }
@@ -447,7 +462,8 @@ namespace Fig
             {
                 error = SyntaxError(FString(std::format("Illegal number literal: {}", numStr.toBasicString())),
                                     this->line,
-                                    it.column());
+                                    it.column(),
+                                    SourceInfo(this));
                 return IllegalTok;
             }
         }
@@ -472,9 +488,10 @@ namespace Fig
 
         if (!startsWith(sym))
         {
-            error = SyntaxError(
-                FString(std::format("No such operator: {}", sym.toBasicString())),
-                this->line, it.column());
+            error = SyntaxError(FString(std::format("No such operator: {}", sym.toBasicString())),
+                                this->line,
+                                it.column(),
+                                SourceInfo(this));
             next();
             return IllegalTok;
         }
@@ -500,9 +517,10 @@ namespace Fig
 
         if (!symbol_map.contains(sym))
         {
-            error = SyntaxError(
-                FString(std::format("No such operator: {}", sym.toBasicString())),
-                this->line, it.column());
+            error = SyntaxError(FString(std::format("No such operator: {}", sym.toBasicString())),
+                                this->line,
+                                it.column(),
+                                SourceInfo(this));
             next();
             return IllegalTok;
         }
@@ -562,7 +580,8 @@ namespace Fig
 
             if (!terminated)
             {
-                error = SyntaxError(FString(u8"Unterminated multiline comment"), this->line, it.column());
+                error =
+                    SyntaxError(FString(u8"Unterminated multiline comment"), this->line, it.column(), SourceInfo(this));
                 next();
                 return IllegalTok;
             }
@@ -633,9 +652,11 @@ namespace Fig
         }
         else
         {
-            error = SyntaxError(FString(
-                                    std::format("Cannot tokenize char: '{}'", FString(ch.getString()).toBasicString())),
-                                this->line, it.column());
+            error =
+                SyntaxError(FString(std::format("Cannot tokenize char: '{}'", FString(ch.getString()).toBasicString())),
+                            this->line,
+                            it.column(),
+                            SourceInfo(this));
             if (hasNext())
             {
                 next();

src/Lexer/lexer.hpp

@@ -23,6 +23,9 @@ namespace Fig
         SyntaxError error;
         UTF8Iterator it;
 
+        FString sourcePath;
+        std::vector<FString> sourceLines;
+
         std::vector<Warning> warnings;
 
         size_t last_line, last_column, column = 1;
@@ -60,8 +63,8 @@ namespace Fig
         static const std::unordered_map<FString, TokenType> symbol_map;
         static const std::unordered_map<FString, TokenType> keyword_map;
 
-        inline Lexer(const FString &_source) :
-            source(_source), it(source)
+        inline Lexer(const FString &_source, const FString &_sourcePath, const std::vector<FString> &_sourceLines) :
+            source(_source), it(source), sourcePath(_sourcePath), sourceLines(_sourceLines)
         {
             line = 1;
         }

src/Module/Library/lang/lang.fig

@@ -31,6 +31,65 @@ public interface Error
     getErrorMessage() -> String;
 }
 
+public struct TypeError
+{
+    public msg: String;
+}
+
+impl Error for TypeError
+{
+    toString()
+    {
+        return "TypeError: " + getErrorMessage();
+    }
+    getErrorClass()
+    {
+        return "TypeError";
+    }
+    getErrorMessage()
+    {
+        return msg;
+    }
+}
+
+// Operation interface
+
+public interface Operation
+{
+// math
+    Add(T, T) -> T;
+    Sub(T, T) -> T;
+    Mul(T, T) -> T;
+    Div(T, T) -> T;
+    Mod(T, T) -> T;
+    Pow(T, T) -> T;
+
+// logic
+    Neg(T) -> T;
+    Not(T) -> T;
+
+    And(T, T) -> T;
+    Or(T, T) -> T;
+
+// comparision
+    Equal(T, T) -> T;
+    NotEqual(T, T) -> T;
+    LessThan(T, T) -> T;
+    LessEqual(T, T) -> T;
+    GreaterThan(T, T) -> T;
+    GreaterEqual(T, T) -> T;
+    Is(T, T) -> T;
+
+// Bit
+    BitNot(T) -> T;
+
+    BitAnd(T, T) -> T;
+    BitOr(T, T) -> T;
+    BitXor(T, T) -> T;
+    ShiftLeft(T, T) -> T;
+    ShiftRight(T, T) -> T:
+}
+
 public struct Any {}
 public struct Int {}
 public struct Null {}

src/Module/Library/std/formater/formater.fig

@@ -33,14 +33,14 @@ public func format(objects ...) -> Any
 {
     if objects.length() < 1
     {
-        throw FormatError{"Require format string"};
+        throw new FormatError{"Require format string"};
     }
 
     var fmt := objects[0];
     var fmtType := value.type(fmt);
     if fmtType != "String"
     {
-        throw FormatError{"arg 0 (fmt) must be String type, got " + fmtType};
+        throw new FormatError{"arg 0 (fmt) must be String type, got " + fmtType};
     }
 
     var result := "";
@@ -56,7 +56,7 @@ public func format(objects ...) -> Any
         {
             if (i + 1 >= length)
             {
-                throw FormatError{"unclosed brace"};
+                throw new FormatError{"unclosed brace"};
             }
             
             var nextChar = fmt[i + 1];
@@ -80,12 +80,12 @@ public func format(objects ...) -> Any
             
             if endIndex == -1
             {
-                throw FormatError{"unclosed brace"};
+                throw new FormatError{"unclosed brace"};
             }
             
             if argIndex >= objects.length()
             {
-                throw FormatError{"require enough format expression"};
+                throw new FormatError{"require enough format expression"};
             }
             
             result += value.string_from(objects[argIndex]);
@@ -102,7 +102,7 @@ public func format(objects ...) -> Any
                 continue;
             }
             
-            throw FormatError{"invalid format syntax"};
+            throw new FormatError{"invalid format syntax"};
         }
         else
         {
@@ -122,14 +122,14 @@ public func formatByListArgs(objects) -> Any
     }
 if objects.length() < 1
     {
-        throw FormatError{"Require format string"};
+        throw new FormatError{"Require format string"};
     }
 
     var fmt := objects[0];
     var fmtType := value.type(fmt);
     if fmtType != "String"
     {
-        throw FormatError{"arg 0 (fmt) must be String type, got " + fmtType};
+        throw new FormatError{"arg 0 (fmt) must be String type, got " + fmtType};
     }
 
     var result := "";
@@ -145,7 +145,7 @@ if objects.length() < 1
         {
             if (i + 1 >= length)
             {
-                throw FormatError{"unclosed brace"};
+                throw new FormatError{"unclosed brace"};
             }
             
             var nextChar = fmt[i + 1];
@@ -169,12 +169,12 @@ if objects.length() < 1
             
             if endIndex == -1
             {
-                throw FormatError{"unclosed brace"};
+                throw new FormatError{"unclosed brace"};
             }
             
             if argIndex >= objects.length()
             {
-                throw FormatError{"require enough format expression"};
+                throw new FormatError{"require enough format expression"};
             }
             
             result += value.string_from(objects[argIndex]);
@@ -191,7 +191,7 @@ if objects.length() < 1
                 continue;
             }
             
-            throw FormatError{"invalid format syntax"};
+            throw new FormatError{"invalid format syntax"};
         }
         else
         {

src/Module/Library/std/std.fig

@@ -3,6 +3,12 @@
     Library/std/std.fig
 */
 
-import io;    // link std.io
-import value; // link std.type
-import math;  // link std.math
+import io as std_io;
+import value as std_value;
+import math as std_math; 
+import test as std_test; 
+
+public const io := std_io;        // link std.io
+public const value := std_value;  // link std.type
+public const math := std_math;    // link std.math
+public const test := std_test;    // link std.test

src/Module/Library/std/test/test.fig

@@ -0,0 +1,86 @@
+/*
+    Official Module `std.test`
+    Library/std/test/test.fig
+
+    Copyright © 2025 PuqiAR. All rights reserved.
+*/
+
+
+
+import std.time;
+import std.io;
+
+// import std.value;
+// import std.math;
+// import std.formater;
+
+// const library_load_time := time.now();
+// io.println("All std libraries loaded! Cost:", library_load_time.toSeconds(), "s\n");
+
+public struct Test
+{
+    public case: String;
+    public fn: Function;
+    public expect_result: Any;
+
+    public func Run()
+    {
+        const start := time.now();
+        const result := fn();
+        const end := time.now();
+
+        const duration := new time.Time{ end.since(start) };
+
+        if result != expect_result
+        {
+            io.println("❌ Test '" + case + "'" + " failed");
+            io.println("    expect", expect_result, ", got", result);
+
+            return 1;
+        }
+        else
+        {
+            io.println("✔ Test '" + case + "'" + " succeed");
+            io.println("    result:", result);
+
+            return 0;
+        }
+    }
+}
+
+public struct Tester
+{
+    public tests: List = [];
+
+    public func AddTest(test: Test)
+    {
+        tests.push(test);
+    }
+
+    public func TestAll()
+    {
+        const numtests := tests.length();
+        
+        var success := 0;
+        var fail := 0;
+
+        for var i := 0; i < numtests; i += 1
+        {
+            io.printf("({}/{})", i + 1, numtests);
+            var result := tests[i].Run();
+            if result == 0
+            {
+                success += 1;
+            }
+            else
+            {
+                fail += 1;
+            }
+        }
+        io.println();
+        io.println("=" * 100);
+        io.println("All tests executed");
+        io.printf("  ({}/{}) success tested!\n", success, numtests);
+        io.printf("  ({}/{}) failed!\n", fail, numtests);    
+    }
+}

src/Module/Library/std/time/time.fig

@@ -0,0 +1,62 @@
+/*
+    Official Module `time`
+    Library/time/time.fig
+    
+    Copyright © 2026 PuqiAR. All rights reserved.
+*/
+
+import _builtins; // provides __ftime_now_ns (int64_t)
+
+
+public struct Time
+{
+    ns: Int; // int64_t, private
+
+    public func toNanos() -> Int
+    {
+        return ns;
+    }
+
+    public func toMicros() -> Int
+    {
+        return __fvalue_int_from(ns / 1000); // convert double to int
+    }
+
+    public func toMillis() -> Double
+    {
+        return ns / 1000 / 1000;
+    }
+
+    public func toSeconds() -> Double
+    {
+        return ns / 1000 / 1000 / 1000;
+    }
+
+    public func since(other: Time) -> Int
+    {
+        const time_ns := other.toNanos();
+        const result := ns - time_ns;
+        if result < 0
+        {
+            throw "time has been reversed! 😢";
+        }
+        return result;
+    }
+    // TODO: support `-` operator when Fig supports overload
+    // supported now! 26-2-2. PuqiAR
+} 
+
+impl Operation for Time
+{
+    Sub(l: Time, r: Time)
+    {
+        return new Time{
+            l.since(r)
+        };
+    }
+}
+
+public func now() -> Time
+{
+    return new Time{__ftime_now_ns()};
+}

src/Module/Library/std/value/value.fig

@@ -7,7 +7,7 @@
 
 import _builtins;
 
-public func type(object: Any) -> String
+public func _type(object: Any) -> String
 {
     return __fvalue_type(object);
 }

src/Module/builtins.cpp

@@ -0,0 +1,427 @@
+#include <Ast/Expressions/BinaryExpr.hpp>
+#include <Ast/Expressions/FunctionCall.hpp>
+#include <Ast/Expressions/ValueExpr.hpp>
+#include <Ast/Expressions/VarExpr.hpp>
+#include <Ast/Statements/ControlSt.hpp>
+#include <Ast/astBase.hpp>
+#include <Ast/functionParameters.hpp>
+#include <Evaluator/Context/context.hpp>
+#include <Core/fig_string.hpp>
+#include <Ast/AccessModifier.hpp>
+#include <Evaluator/Value/structType.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Module/builtins.hpp>
+
+#include <memory>
+#include <print>
+#include <iostream>
+#include <cmath>
+#include <chrono>
+#include <numeric>
+#include <unordered_map>
+
+namespace Fig::Builtins
+{
+    const TypeInfo &getErrorInterfaceTypeInfo()
+    {
+        static const TypeInfo ErrorInterfaceTypeInfo(u8"Error", true);
+        return ErrorInterfaceTypeInfo;
+    }
+    const TypeInfo &getTypeErrorStructTypeInfo()
+    {
+        static const TypeInfo TypeErrorStructTypeInfo(u8"TypeError", true);
+        return TypeErrorStructTypeInfo;
+    }
+    const TypeInfo &getOperationInterfaceTypeInfo()
+    {
+        static const TypeInfo OperationInterfaceTypeInfo(u8"Operation", true);
+        return OperationInterfaceTypeInfo;
+    }
+    const std::unordered_map<FString, ObjectPtr> &getBuiltinValues()
+    {
+        static const std::unordered_map<FString, ObjectPtr> builtinValues = {
+            {u8"null", Object::getNullInstance()},
+            {u8"true", Object::getTrueInstance()},
+            {u8"false", Object::getFalseInstance()},
+            {u8"Error",
+             std::make_shared<Object>(InterfaceType(getErrorInterfaceTypeInfo(),
+                                                    {Ast::InterfaceMethod(u8"toString",
+                                                                          Ast::FunctionParameters({}, {}),
+                                                                          std::make_shared<Ast::VarExprAst>(u8"String"),
+                                                                          nullptr),
+                                                     Ast::InterfaceMethod(u8"getErrorClass",
+                                                                          Ast::FunctionParameters({}, {}),
+                                                                          std::make_shared<Ast::VarExprAst>(u8"String"),
+                                                                          nullptr),
+                                                     Ast::InterfaceMethod(u8"getErrorMessage",
+                                                                          Ast::FunctionParameters({}, {}),
+                                                                          std::make_shared<Ast::VarExprAst>(u8"String"),
+                                                                          nullptr)}))},
+                {u8"TypeError", std::make_shared<Object>(StructType(
+                    getTypeErrorStructTypeInfo(),
+                    std::make_shared<Context>(u8"<Built-in `TypeError`>"),
+                    {Field(AccessModifier::Public, u8"msg", ValueType::String, nullptr)}
+                ))},
+            {u8"Operation", std::make_shared<Object>(InterfaceType(getOperationInterfaceTypeInfo(), {}))},
+
+            {u8"Any", std::make_shared<Object>(StructType(ValueType::Any, nullptr, {}, true))},
+            {u8"Int", std::make_shared<Object>(StructType(ValueType::Int, nullptr, {}, true))},
+            {u8"Null", std::make_shared<Object>(StructType(ValueType::Null, nullptr, {}, true))},
+            {u8"String", std::make_shared<Object>(StructType(ValueType::String, nullptr, {}, true))},
+            {u8"Bool", std::make_shared<Object>(StructType(ValueType::Bool, nullptr, {}, true))},
+            {u8"Double", std::make_shared<Object>(StructType(ValueType::Double, nullptr, {}, true))},
+            {u8"Function", std::make_shared<Object>(StructType(ValueType::Function, nullptr, {}, true))},
+            {u8"List", std::make_shared<Object>(StructType(ValueType::List, nullptr, {}, true))},
+            {u8"Map", std::make_shared<Object>(StructType(ValueType::Map, nullptr, {}, true))},
+            // Type `StructType` `StructInstance` `Module` `InterfaceType`
+            // Not allowed to call constructor!
+
+            {u8"type", std::make_shared<Object>(Function(
+                u8"type",
+                [](const std::vector<ObjectPtr> &_args) -> ObjectPtr
+                {
+                    const ObjectPtr &arg = _args[0];
+                    return std::make_shared<Object>(prettyType(arg));
+                },
+                1
+            ))},
+        };
+        return builtinValues;
+    }
+    const std::unordered_map<FString, int> &getBuiltinFunctionArgCounts()
+    {
+        static const std::unordered_map<FString, int> builtinFunctionArgCounts = {
+            {u8"__fstdout_print", -1},   // variadic
+            {u8"__fstdout_println", -1}, // variadic
+            {u8"__fstdin_read", 0},
+            {u8"__fstdin_readln", 0},
+            {u8"__fvalue_type", 1},
+            {u8"__fvalue_int_parse", 1},
+            {u8"__fvalue_int_from", 1},
+            {u8"__fvalue_double_parse", 1},
+            {u8"__fvalue_double_from", 1},
+            {u8"__fvalue_string_from", 1},
+            {u8"__ftime_now_ns", 0},
+            /* math start */
+            {u8"__fmath_acos", 1},
+            {u8"__fmath_acosh", 1},
+            {u8"__fmath_asin", 1},
+            {u8"__fmath_asinh", 1},
+            {u8"__fmath_atan", 1},
+            {u8"__fmath_atan2", 2},
+            {u8"__fmath_atanh", 1},
+            {u8"__fmath_ceil", 1},
+            {u8"__fmath_cos", 1},
+            {u8"__fmath_cosh", 1},
+            {u8"__fmath_exp", 1},
+            {u8"__fmath_expm1", 1},
+            {u8"__fmath_fabs", 1},
+            {u8"__fmath_floor", 1},
+            {u8"__fmath_fmod", 2},
+            {u8"__fmath_frexp", 1},
+            {u8"__fmath_gcd", 2},
+            {u8"__fmath_hypot", 2},
+            {u8"__fmath_isequal", 2},
+            {u8"__fmath_log", 1},
+            {u8"__fmath_log10", 1},
+            {u8"__fmath_log1p", 1},
+            {u8"__fmath_log2", 1},
+            {u8"__fmath_sin", 1},
+            {u8"__fmath_sinh", 1},
+            {u8"__fmath_sqrt", 1},
+            {u8"__fmath_tan", 1},
+            {u8"__fmath_tanh", 1},
+            {u8"__fmath_trunc", 1},
+        };
+        return builtinFunctionArgCounts;
+    }
+    const std::unordered_map<FString, BuiltinFunction> &getBuiltinFunctions()
+    {
+        static const std::unordered_map<FString, BuiltinFunction> builtinFunctions{
+            {u8"__fstdout_print",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
+                 return std::make_shared<Object>(ValueType::IntClass(args.size()));
+             }},
+            {u8"__fstdout_println",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
+                 std::print("\n");
+                 return std::make_shared<Object>(ValueType::IntClass(args.size()));
+             }},
+            {u8"__fstdin_read",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 std::string input;
+                 std::cin >> input;
+                 return std::make_shared<Object>(FString::fromBasicString(input));
+             }},
+            {u8"__fstdin_readln",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 std::string line;
+                 std::getline(std::cin, line);
+                 return std::make_shared<Object>(FString::fromBasicString(line));
+             }},
+            {u8"__fvalue_type",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 return std::make_shared<Object>(args[0]->getTypeInfo().toString());
+             }},
+            {u8"__fvalue_int_parse",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 FString str = args[0]->as<ValueType::StringClass>();
+                 try
+                 {
+                     ValueType::IntClass val = std::stoi(str.toBasicString());
+                     return std::make_shared<Object>(val);
+                 }
+                 catch (...)
+                 {
+                     throw RuntimeError(FString(std::format("Invalid int string for parsing", str.toBasicString())));
+                 }
+             }},
+            {u8"__fvalue_int_from",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 if (val->is<ValueType::DoubleClass>())
+                 {
+                     return std::make_shared<Object>(
+                         static_cast<ValueType::IntClass>(val->as<ValueType::DoubleClass>()));
+                 }
+                 else if (val->is<ValueType::BoolClass>())
+                 {
+                     return std::make_shared<Object>(
+                         static_cast<ValueType::IntClass>(val->as<ValueType::BoolClass>() ? 1 : 0));
+                 }
+                 else
+                 {
+                     throw RuntimeError(FString(std::format("Type '{}' cannot be converted to int",
+                                                            val->getTypeInfo().toString().toBasicString())));
+                 }
+             }},
+            {u8"__fvalue_double_parse",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 FString str = args[0]->as<ValueType::StringClass>();
+                 try
+                 {
+                     ValueType::DoubleClass val = std::stod(str.toBasicString());
+                     return std::make_shared<Object>(ValueType::DoubleClass(val));
+                 }
+                 catch (...)
+                 {
+                     throw RuntimeError(FString(std::format("Invalid double string for parsing", str.toBasicString())));
+                 }
+             }},
+            {u8"__fvalue_double_from",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 if (val->is<ValueType::IntClass>())
+                 {
+                     return std::make_shared<Object>(
+                         static_cast<ValueType::DoubleClass>(val->as<ValueType::IntClass>()));
+                 }
+                 else if (val->is<ValueType::BoolClass>())
+                 {
+                     return std::make_shared<Object>(
+                         ValueType::DoubleClass(val->as<ValueType::BoolClass>() ? 1.0 : 0.0));
+                 }
+                 else
+                 {
+                     throw RuntimeError(FString(std::format("Type '{}' cannot be converted to double",
+                                                            val->getTypeInfo().toString().toBasicString())));
+                 }
+             }},
+            {u8"__fvalue_string_from",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 return std::make_shared<Object>(val->toStringIO());
+             }},
+            {u8"__ftime_now_ns",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 // returns nanoseconds
+                 using namespace Fig::Time;
+                 auto now = Clock::now();
+                 return std::make_shared<Object>(static_cast<ValueType::IntClass>(
+                     std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time).count()));
+             }},
+
+            /* math start */
+            {u8"__fmath_acos",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(acos(d));
+             }},
+            {u8"__fmath_acosh",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(acosh(d));
+             }},
+            {u8"__fmath_asin",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(asin(d));
+             }},
+            {u8"__fmath_asinh",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(asinh(d));
+             }},
+            {u8"__fmath_atan",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(atan(d));
+             }},
+            {u8"__fmath_atan2",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass y = args[0]->getNumericValue();
+                 ValueType::DoubleClass x = args[1]->getNumericValue();
+                 return std::make_shared<Object>(atan2(y, x));
+             }},
+            {u8"__fmath_atanh",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(atanh(d));
+             }},
+            {u8"__fmath_ceil",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(ceil(d));
+             }},
+            {u8"__fmath_cos",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(cos(d));
+             }},
+            {u8"__fmath_cosh",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(cosh(d));
+             }},
+            {u8"__fmath_exp",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(exp(d));
+             }},
+            {u8"__fmath_expm1",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(expm1(d));
+             }},
+            {u8"__fmath_fabs",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(fabs(d));
+             }},
+            {u8"__fmath_floor",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(floor(d));
+             }},
+            {u8"__fmath_fmod",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass x = args[0]->getNumericValue();
+                 ValueType::DoubleClass y = args[1]->getNumericValue();
+                 return std::make_shared<Object>(fmod(x, y));
+             }},
+            {u8"__fmath_frexp",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 int e;
+                 return std::make_shared<Object>(List({std::make_shared<Object>(frexp(d, &e)),
+                                                       std::make_shared<Object>(static_cast<ValueType::IntClass>(e))}));
+             }},
+            {u8"__fmath_gcd",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::IntClass x = args[0]->as<ValueType::IntClass>();
+                 ValueType::IntClass y = args[1]->as<ValueType::IntClass>();
+                 return std::make_shared<Object>(std::gcd(x, y));
+             }},
+            {u8"__fmath_hypot",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass x = args[0]->getNumericValue();
+                 ValueType::DoubleClass y = args[1]->getNumericValue();
+                 return std::make_shared<Object>(hypot(x, y));
+             }},
+            {u8"__fmath_isequal",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass x = args[0]->getNumericValue();
+                 ValueType::DoubleClass y = args[1]->getNumericValue();
+                 static const double epsilon = 1e-9;
+                 return std::make_shared<Object>(fabs(x - y) < epsilon);
+             }},
+            {u8"__fmath_log",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log(d));
+             }},
+            {u8"__fmath_log10",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log10(d));
+             }},
+            {u8"__fmath_log1p",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log1p(d));
+             }},
+            {u8"__fmath_log2",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log2(d));
+             }},
+            {u8"__fmath_sin",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(sin(d));
+             }},
+            {u8"__fmath_sinh",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(sinh(d));
+             }},
+            {u8"__fmath_sqrt",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(sqrt(d));
+             }},
+            {u8"__fmath_tan",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(tan(d));
+             }},
+            {u8"__fmath_tanh",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(tanh(d));
+             }},
+            {u8"__fmath_trunc",
+             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(trunc(d));
+             }},
+        };
+        return builtinFunctions;
+    }
+} // namespace Fig::Builtins

src/Module/builtins.hpp

@@ -1,23 +1,21 @@
 #pragma once
 
-#include "Ast/Statements/InterfaceDefSt.hpp"
-#include "Ast/functionParameters.hpp"
-#include <Core/fig_string.hpp>
-#include <Value/value.hpp>
+#include <Ast/Expressions/VarExpr.hpp>
+
+#include <Ast/functionParameters.hpp>
+#include <Core/fig_string.hpp>
+#include <Evaluator/Value/value.hpp>
+#include <Core/runtimeTime.hpp>
 
-#include <numeric>
 #include <unordered_map>
 #include <functional>
 #include <vector>
-#include <print>
-#include <iostream>
-#include <cmath>
 
 namespace Fig
 {
     namespace Builtins
     {
-        const TypeInfo ErrorInterfaceTypeInfo(u8"Error", true);
+
         /*
             // error's interface like:
             interface Error
@@ -28,361 +26,35 @@ namespace Fig
             }
         */
 
-        const std::unordered_map<FString, ObjectPtr> builtinValues = {
-            {u8"null", Object::getNullInstance()},
-            {u8"true", Object::getTrueInstance()},
-            {u8"false", Object::getFalseInstance()},
-            {u8"Error",
-             std::make_shared<Object>(InterfaceType(
-                 ErrorInterfaceTypeInfo,
-                 {Ast::InterfaceMethod(u8"toString", Ast::FunctionParameters({}, {}), u8"String", nullptr),
-                  Ast::InterfaceMethod(u8"getErrorClass", Ast::FunctionParameters({}, {}), u8"String", nullptr),
-                  Ast::InterfaceMethod(u8"getErrorMessage", Ast::FunctionParameters({}, {}), u8"String", nullptr)}))},
+        const TypeInfo &getErrorInterfaceTypeInfo();
 
-            {u8"Any", std::make_shared<Object>(StructType(ValueType::Any, nullptr, {}, true))},
-            {u8"Int", std::make_shared<Object>(StructType(ValueType::Int, nullptr, {}, true))},
-            {u8"Null", std::make_shared<Object>(StructType(ValueType::Null, nullptr, {}, true))},
-            {u8"String", std::make_shared<Object>(StructType(ValueType::String, nullptr, {}, true))},
-            {u8"Bool", std::make_shared<Object>(StructType(ValueType::Bool, nullptr, {}, true))},
-            {u8"Double", std::make_shared<Object>(StructType(ValueType::Double, nullptr, {}, true))},
-            {u8"Function", std::make_shared<Object>(StructType(ValueType::Function, nullptr, {}, true))},
-            {u8"List", std::make_shared<Object>(StructType(ValueType::List, nullptr, {}, true))},
-            {u8"Map", std::make_shared<Object>(StructType(ValueType::Map, nullptr, {}, true))},
-            // Type `StructType` `StructInstance` `Module` `InterfaceType`
-            // Not allowed to call constructor!
-        };
+        const TypeInfo &getTypeErrorStructTypeInfo();
+        /*
+            interface Operation
+            {
+                add(..., ...) -> ...;
+            }
+        
+        */
+
+        const TypeInfo &getOperationInterfaceTypeInfo();
+
+        const std::unordered_map<FString, ObjectPtr> &getBuiltinValues();
 
         using BuiltinFunction = std::function<ObjectPtr(const std::vector<ObjectPtr> &)>;
 
-        const std::unordered_map<FString, int> builtinFunctionArgCounts = {
-            {u8"__fstdout_print", -1},   // variadic
-            {u8"__fstdout_println", -1}, // variadic
-            {u8"__fstdin_read", 0},
-            {u8"__fstdin_readln", 0},
-            {u8"__fvalue_type", 1},
-            {u8"__fvalue_int_parse", 1},
-            {u8"__fvalue_int_from", 1},
-            {u8"__fvalue_double_parse", 1},
-            {u8"__fvalue_double_from", 1},
-            {u8"__fvalue_string_from", 1},
-            /* math start */
-            {u8"__fmath_acos", 1},
-            {u8"__fmath_acosh", 1},
-            {u8"__fmath_asin", 1},
-            {u8"__fmath_asinh", 1},
-            {u8"__fmath_atan", 1},
-            {u8"__fmath_atan2", 2},
-            {u8"__fmath_atanh", 1},
-            {u8"__fmath_ceil", 1},
-            {u8"__fmath_cos", 1},
-            {u8"__fmath_cosh", 1},
-            {u8"__fmath_exp", 1},
-            {u8"__fmath_expm1", 1},
-            {u8"__fmath_fabs", 1},
-            {u8"__fmath_floor", 1},
-            {u8"__fmath_fmod", 2},
-            {u8"__fmath_frexp", 1},
-            {u8"__fmath_gcd", 2},
-            {u8"__fmath_hypot", 2},
-            {u8"__fmath_isequal", 2},
-            {u8"__fmath_log", 1},
-            {u8"__fmath_log10", 1},
-            {u8"__fmath_log1p", 1},
-            {u8"__fmath_log2", 1},
-            {u8"__fmath_sin", 1},
-            {u8"__fmath_sinh", 1},
-            {u8"__fmath_sqrt", 1},
-            {u8"__fmath_tan", 1},
-            {u8"__fmath_tanh", 1},
-            {u8"__fmath_trunc", 1},
-        };
-
-        const std::unordered_map<FString, BuiltinFunction> builtinFunctions{
-            {u8"__fstdout_print",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
-                 return std::make_shared<Object>(ValueType::IntClass(args.size()));
-             }},
-            {u8"__fstdout_println",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 for (auto arg : args) { std::print("{}", arg->toStringIO().toBasicString()); }
-                 std::print("\n");
-                 return std::make_shared<Object>(ValueType::IntClass(args.size()));
-             }},
-            {u8"__fstdin_read",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 std::string input;
-                 std::cin >> input;
-                 return std::make_shared<Object>(FString::fromBasicString(input));
-             }},
-            {u8"__fstdin_readln",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 std::string line;
-                 std::getline(std::cin, line);
-                 return std::make_shared<Object>(FString::fromBasicString(line));
-             }},
-            {u8"__fvalue_type",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 return std::make_shared<Object>(args[0]->getTypeInfo().toString());
-             }},
-            {u8"__fvalue_int_parse",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 FString str = args[0]->as<ValueType::StringClass>();
-                 try
-                 {
-                     ValueType::IntClass val = std::stoi(str.toBasicString());
-                     return std::make_shared<Object>(val);
-                 }
-                 catch (...)
-                 {
-                     throw RuntimeError(FString(std::format("Invalid int string for parsing", str.toBasicString())));
-                 }
-             }},
-            {u8"__fvalue_int_from",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 if (val->is<ValueType::DoubleClass>())
-                 {
-                     return std::make_shared<Object>(
-                         static_cast<ValueType::IntClass>(val->as<ValueType::DoubleClass>()));
-                 }
-                 else if (val->is<ValueType::BoolClass>())
-                 {
-                     return std::make_shared<Object>(
-                         static_cast<ValueType::IntClass>(val->as<ValueType::BoolClass>() ? 1 : 0));
-                 }
-                 else
-                 {
-                     throw RuntimeError(FString(std::format("Type '{}' cannot be converted to int",
-                                                            val->getTypeInfo().toString().toBasicString())));
-                 }
-             }},
-            {u8"__fvalue_double_parse",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 FString str = args[0]->as<ValueType::StringClass>();
-                 try
-                 {
-                     ValueType::DoubleClass val = std::stod(str.toBasicString());
-                     return std::make_shared<Object>(ValueType::DoubleClass(val));
-                 }
-                 catch (...)
-                 {
-                     throw RuntimeError(FString(std::format("Invalid double string for parsing", str.toBasicString())));
-                 }
-             }},
-            {u8"__fvalue_double_from",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 if (val->is<ValueType::IntClass>())
-                 {
-                     return std::make_shared<Object>(
-                         static_cast<ValueType::DoubleClass>(val->as<ValueType::IntClass>()));
-                 }
-                 else if (val->is<ValueType::BoolClass>())
-                 {
-                     return std::make_shared<Object>(
-                         ValueType::DoubleClass(val->as<ValueType::BoolClass>() ? 1.0 : 0.0));
-                 }
-                 else
-                 {
-                     throw RuntimeError(FString(std::format("Type '{}' cannot be converted to double",
-                                                            val->getTypeInfo().toString().toBasicString())));
-                 }
-             }},
-            {u8"__fvalue_string_from",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 return std::make_shared<Object>(val->toStringIO());
-             }},
-            /* math start */
-            {u8"__fmath_acos",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(acos(d));
-             }},
-            {u8"__fmath_acosh",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(acosh(d));
-             }},
-            {u8"__fmath_asin",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(asin(d));
-             }},
-            {u8"__fmath_asinh",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(asinh(d));
-             }},
-            {u8"__fmath_atan",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(atan(d));
-             }},
-            {u8"__fmath_atan2",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ValueType::DoubleClass y = args[0]->getNumericValue();
-                 ValueType::DoubleClass x = args[1]->getNumericValue();
-                 return std::make_shared<Object>(atan2(y, x));
-             }},
-            {u8"__fmath_atanh",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(atanh(d));
-             }},
-            {u8"__fmath_ceil",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(ceil(d));
-             }},
-            {u8"__fmath_cos",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(cos(d));
-             }},
-            {u8"__fmath_cosh",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(cosh(d));
-             }},
-            {u8"__fmath_exp",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(exp(d));
-             }},
-            {u8"__fmath_expm1",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(expm1(d));
-             }},
-            {u8"__fmath_fabs",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(fabs(d));
-             }},
-            {u8"__fmath_floor",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(floor(d));
-             }},
-            {u8"__fmath_fmod",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ValueType::DoubleClass x = args[0]->getNumericValue();
-                 ValueType::DoubleClass y = args[1]->getNumericValue();
-                 return std::make_shared<Object>(fmod(x, y));
-             }},
-            {u8"__fmath_frexp",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 int e;
-                 return std::make_shared<Object>(List({std::make_shared<Object>(frexp(d, &e)),
-                                                       std::make_shared<Object>(static_cast<ValueType::IntClass>(e))}));
-             }},
-            {u8"__fmath_gcd",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ValueType::IntClass x = args[0]->as<ValueType::IntClass>();
-                 ValueType::IntClass y = args[1]->as<ValueType::IntClass>();
-                 return std::make_shared<Object>(std::gcd(x, y));
-             }},
-            {u8"__fmath_hypot",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ValueType::DoubleClass x = args[0]->getNumericValue();
-                 ValueType::DoubleClass y = args[1]->getNumericValue();
-                 return std::make_shared<Object>(hypot(x, y));
-             }},
-            {u8"__fmath_isequal",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ValueType::DoubleClass x = args[0]->getNumericValue();
-                 ValueType::DoubleClass y = args[1]->getNumericValue();
-                 static const double epsilon = 1e-9;
-                 return std::make_shared<Object>(fabs(x - y) < epsilon);
-             }},
-            {u8"__fmath_log",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(log(d));
-             }},
-            {u8"__fmath_log10",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(log10(d));
-             }},
-            {u8"__fmath_log1p",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(log1p(d));
-             }},
-            {u8"__fmath_log2",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(log2(d));
-             }},
-            {u8"__fmath_sin",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(sin(d));
-             }},
-            {u8"__fmath_sinh",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(sinh(d));
-             }},
-            {u8"__fmath_sqrt",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(sqrt(d));
-             }},
-            {u8"__fmath_tan",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(tan(d));
-             }},
-            {u8"__fmath_tanh",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(tanh(d));
-             }},
-            {u8"__fmath_trunc",
-             [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
-                 ObjectPtr val = args[0];
-                 ValueType::DoubleClass d = val->getNumericValue();
-                 return std::make_shared<Object>(trunc(d));
-             }},
-        };
+        const std::unordered_map<FString, int> &getBuiltinFunctionArgCounts();
+        const std::unordered_map<FString, BuiltinFunction> &getBuiltinFunctions();
 
         inline bool isBuiltinFunction(const FString &name)
         {
-            return builtinFunctions.find(name) != builtinFunctions.end();
+            return getBuiltinFunctions().find(name) != getBuiltinFunctions().end();
         }
 
         inline BuiltinFunction getBuiltinFunction(const FString &name)
         {
-            auto it = builtinFunctions.find(name);
-            if (it == builtinFunctions.end())
+            auto it = getBuiltinFunctions().find(name);
+            if (it == getBuiltinFunctions().end())
             {
                 throw RuntimeError(FString(std::format("Builtin function '{}' not found", name.toBasicString())));
             }
@@ -391,8 +63,8 @@ namespace Fig
 
         inline int getBuiltinFunctionParamCount(const FString &name)
         {
-            auto it = builtinFunctionArgCounts.find(name);
-            if (it == builtinFunctionArgCounts.end())
+            auto it = getBuiltinFunctionArgCounts().find(name);
+            if (it == getBuiltinFunctionArgCounts().end())
             {
                 throw RuntimeError(FString(std::format("Builtin function '{}' not found", name.toBasicString())));
             }

src/Parser/parser.cpp

@@ -1,70 +1,85 @@
-#include "Ast/Statements/ErrorFlow.hpp"
-#include "Ast/Statements/ImplementSt.hpp"
-#include "Ast/astBase.hpp"
-#include "Ast/functionParameters.hpp"
-#include "Error/error.hpp"
-#include "Token/token.hpp"
+#include <Ast/Expressions/VarExpr.hpp>
+#include <Ast/Statements/ErrorFlow.hpp>
+#include <Ast/Statements/ImplementSt.hpp>
+#include <Ast/astBase.hpp>
+#include <Ast/functionParameters.hpp>
+#include <Error/error.hpp>
+#include <Token/token.hpp>
 #include <Parser/parser.hpp>
 
 namespace Fig
 {
     // Operator : pair<LeftBindingPower, RightBindingPower>
-
     const std::unordered_map<Ast::Operator, std::pair<Parser::Precedence, Parser::Precedence>> Parser::opPrecedence = {
-        // 算术
-        {Ast::Operator::Add, {10, 11}},
-        {Ast::Operator::Subtract, {10, 11}},
-        {Ast::Operator::Multiply, {20, 21}},
-        {Ast::Operator::Divide, {20, 21}},
-        {Ast::Operator::Modulo, {20, 21}},
-        {Ast::Operator::Power, {30, 29}},
+        // 赋值类 - 右结合
+        {Ast::Operator::Assign, {20, 10}},
+        {Ast::Operator::PlusAssign, {20, 10}},
+        {Ast::Operator::MinusAssign, {20, 10}},
+        {Ast::Operator::SlashAssign, {20, 10}},
+        {Ast::Operator::AsteriskAssign, {20, 10}},
+        {Ast::Operator::PercentAssign, {20, 10}},
+        {Ast::Operator::CaretAssign, {20, 10}},
 
-        // 逻辑
-        {Ast::Operator::And, {5, 6}},
-        {Ast::Operator::Or, {4, 5}},
-        {Ast::Operator::Not, {30, 31}}, // 一元
+        // 三元条件 - 特殊处理，通常是右结合
+        {Ast::Operator::TernaryCond, {30, 20}},
 
-        // 比较
-        {Ast::Operator::Equal, {7, 8}},
-        {Ast::Operator::NotEqual, {7, 8}},
-        {Ast::Operator::Less, {8, 9}},
-        {Ast::Operator::LessEqual, {8, 9}},
-        {Ast::Operator::Greater, {8, 9}},
-        {Ast::Operator::GreaterEqual, {8, 9}},
-        {Ast::Operator::Is, {8, 9}},
+        // 逻辑或
+        {Ast::Operator::Or, {40, 41}}, // leftBP < rightBP，左结合
 
-        // 位运算
-        {Ast::Operator::BitAnd, {6, 7}},
-        {Ast::Operator::BitOr, {4, 5}},
-        {Ast::Operator::BitXor, {5, 6}},
-        {Ast::Operator::BitNot, {30, 31}}, // 一元
-        {Ast::Operator::ShiftLeft, {15, 16}},
-        {Ast::Operator::ShiftRight, {15, 16}},
+        // 逻辑与
+        {Ast::Operator::And, {50, 51}}, // 比 Or 高
 
-        {Ast::Operator::Assign, {2, 1}}, // 右结合
-        {Ast::Operator::PlusAssign, {2, 1}},
-        {Ast::Operator::MinusAssign, {2, 1}},
-        {Ast::Operator::SlashAssign, {2, 1}},
-        {Ast::Operator::AsteriskAssign, {2, 1}},
-        {Ast::Operator::PercentAssign, {2, 1}},
-        {Ast::Operator::CaretAssign, {2, 1}},
+        // 位或
+        {Ast::Operator::BitOr, {60, 61}},
 
-        // 海象运算符
-        // {Ast::Operator::Walrus, {2, 1}}, // 右结合
+        // 位异或
+        {Ast::Operator::BitXor, {70, 71}},
 
-        // // 点运算符
-        // {Ast::Operator::Dot, {40, 41}},
+        // 位与
+        {Ast::Operator::BitAnd, {80, 81}},
+
+        // 相等比较
+        {Ast::Operator::Equal, {90, 91}},
+        {Ast::Operator::NotEqual, {90, 91}},
+
+        // 关系比较
+        {Ast::Operator::Less, {100, 101}},
+        {Ast::Operator::LessEqual, {100, 101}},
+        {Ast::Operator::Greater, {100, 101}},
+        {Ast::Operator::GreaterEqual, {100, 101}},
+        {Ast::Operator::Is, {100, 101}},
+
+        // 转换
+        {Ast::Operator::As, {105, 106}},
+
+        // 位移
+        {Ast::Operator::ShiftLeft, {110, 111}},
+        {Ast::Operator::ShiftRight, {110, 111}},
+
+        // 加减
+        {Ast::Operator::Add, {120, 121}},
+        {Ast::Operator::Subtract, {120, 121}},
+
+        // 乘除模
+        {Ast::Operator::Multiply, {130, 131}},
+        {Ast::Operator::Divide, {130, 131}},
+        {Ast::Operator::Modulo, {130, 131}},
+
+        // 幂运算 - 右结合
+        {Ast::Operator::Power, {140, 139}}, // leftBP > rightBP
     };
 
+    // 赋值 < 三元 < 逻辑或 < 逻辑与 < 位运算 < 比较 < 位移 < 加减 < 乘除 < 幂 < 一元
+
+    // 一元运算符的优先级比所有二元运算符都高
     const std::unordered_map<Ast::Operator, Parser::Precedence> Parser::unaryOpPrecedence = {
         {Ast::Operator::Subtract, 150}, // -
-        {Ast::Operator::BitAnd, 150}, // &
-        {Ast::Operator::BitNot, 150}, // ~
-        {Ast::Operator::Not, 150}, // !
+        {Ast::Operator::BitNot, 150},   // ~
+        {Ast::Operator::Not, 150},      // !
+        {Ast::Operator::BitAnd, 150},   // &（取地址）
     };
 
-        Ast::VarDef
-        Parser::__parseVarDef(bool isPublic)
+    Ast::VarDef Parser::__parseVarDef(bool isPublic)
     {
         // entry: current is keyword `var` or `const`
         bool isConst = (currentToken().getType() == TokenType::Const ? true : false);
@@ -72,31 +87,31 @@ namespace Fig
         expect(TokenType::Identifier);
         FString name = currentToken().getValue();
         next();
-        FString tiName = ValueType::Any.name;
+        Ast::Expression declaredType = nullptr;
         bool hasSpecificType = false;
         if (isThis(TokenType::Colon)) // :
         {
-            expectPeek(TokenType::Identifier, FString(u8"Type name"));
-            next();
-            tiName = currentToken().getValue();
-            next();
+            next(); // consume `:`
+            declaredType = parseExpression(0, TokenType::Assign, TokenType::Semicolon);
             hasSpecificType = true;
         }
         if (isThis(TokenType::Semicolon))
         {
             next(); // consume `;`, no using expectConsume here cause we don't need to check again
-            return makeAst<Ast::VarDefAst>(isPublic, isConst, name, tiName, nullptr);
+            return makeAst<Ast::VarDefAst>(isPublic, isConst, name, declaredType, nullptr, false);
         }
         if (!isThis(TokenType::Assign) and !isThis(TokenType::Walrus)) expect(TokenType::Assign, u8"assign or walrus");
+        bool followupType = false;
+
         if (isThis(TokenType::Walrus))
         {
             if (hasSpecificType) throwAddressableError<SyntaxError>(FString(u8""));
-            tiName = Parser::varDefTypeFollowed;
+            followupType = true;
         }
         next();
         Ast::Expression exp = parseExpression(0);
         expectSemicolon();
-        return makeAst<Ast::VarDefAst>(isPublic, isConst, name, tiName, exp);
+        return makeAst<Ast::VarDefAst>(isPublic, isConst, name, declaredType, exp, followupType);
     }
 
     ObjectPtr Parser::__parseValue()
@@ -133,18 +148,12 @@ namespace Fig
                 return std::make_shared<Object>(i);
             }
         }
-        else if (currentToken().getType() == TokenType::LiteralString)
-        {
-            return std::make_shared<Object>(_val);
-        }
+        else if (currentToken().getType() == TokenType::LiteralString) { return std::make_shared<Object>(_val); }
         else if (currentToken().getType() == TokenType::LiteralBool)
         {
             return std::make_shared<Object>((_val == u8"true" ? true : false));
         }
-        else if (currentToken().getType() == TokenType::LiteralNull)
-        {
-            return Object::getNullInstance();
-        }
+        else if (currentToken().getType() == TokenType::LiteralNull) { return Object::getNullInstance(); }
         else
         {
             throw std::runtime_error(std::string("Internal Error at: ") + std::string(__func__));
@@ -179,7 +188,7 @@ namespace Fig
             if (isThis(TokenType::Assign)) // =
             {
                 next();
-                dp.push_back({pname, {ValueType::Any.name, parseExpression(0, TokenType::Comma)}});
+                dp.push_back({pname, {makeAst<Ast::VarExprAst>(u8"Any"), parseExpression(0, TokenType::Comma)}});
                 if (isThis(TokenType::Comma))
                 {
                     next(); // only skip `,` when it's there
@@ -188,13 +197,12 @@ namespace Fig
             else if (isThis(TokenType::Colon)) // :
             {
                 next(); // skip `:`
-                expect(TokenType::Identifier, FString(u8"Type name"));
-                FString ti(currentToken().getValue());
-                next();                        // skip type name
+                Ast::Expression type_exp =
+                    parseExpression(0, TokenType::Comma, TokenType::RightParen, TokenType::Assign);
                 if (isThis(TokenType::Assign)) // =
                 {
                     next(); // skip `=`
-                    dp.push_back({pname, {ti, parseExpression(0, TokenType::Comma)}});
+                    dp.push_back({pname, {type_exp, parseExpression(0, TokenType::Comma)}});
                     if (isThis(TokenType::Comma))
                     {
                         next(); // only skip `,` when it's there
@@ -202,7 +210,7 @@ namespace Fig
                 }
                 else
                 {
-                    pp.push_back({pname, ti});
+                    pp.push_back({pname, type_exp});
                     if (isThis(TokenType::Comma))
                     {
                         next(); // only skip `,` when it's there
@@ -214,7 +222,7 @@ namespace Fig
                 variaPara = pname;
                 next(); // skip `...`
                 if (!isThis(TokenType::RightParen))
-                    throw SyntaxError(
+                    throwAddressableError<SyntaxError>(
                         u8"Expects right paren, variable parameter function can only have one parameter",
                         currentAAI.line,
                         currentAAI.column);
@@ -223,7 +231,7 @@ namespace Fig
             }
             else
             {
-                pp.push_back({pname, ValueType::Any.name});
+                pp.push_back({pname, makeAst<Ast::VarExprAst>(u8"Any")});
                 if (isThis(TokenType::Comma))
                 {
                     next(); // only skip `,` when it's there
@@ -237,17 +245,17 @@ namespace Fig
         next();
         expect(TokenType::LeftParen);
         Ast::FunctionParameters params = __parseFunctionParameters();
-        FString retTiName = ValueType::Any.name;
+
+        Ast::Expression returnType;
+
         if (isThis(TokenType::RightArrow)) // ->
         {
             next(); // skip `->`
-            expect(TokenType::Identifier);
-            retTiName = currentToken().getValue();
-            next(); // skip return type
+            returnType = parseExpression(0, TokenType::LeftBrace, TokenType::Semicolon);
         }
         expect(TokenType::LeftBrace);
         Ast::BlockStatement body = __parseBlockStatement();
-        return makeAst<Ast::FunctionDefSt>(funcName, params, isPublic, retTiName, body);
+        return makeAst<Ast::FunctionDefSt>(funcName, params, isPublic, returnType, body);
     }
     Ast::StructDef Parser::__parseStructDef(bool isPublic)
     {
@@ -289,13 +297,11 @@ namespace Fig
             {
                 throwAddressableError<SyntaxError>(FString(std::format("expect field name or field attribute")));
             }
-            FString tiName = ValueType::Any.name;
+            Ast::Expression fieldType = nullptr;
             if (isThis(TokenType::Colon))
             {
-                next();
-                expect(TokenType::Identifier, u8"type name");
-                tiName = currentToken().getValue();
-                next();
+                next(); // consume `:`
+                fieldType = parseExpression(0, TokenType::Assign, TokenType::Semicolon);
             }
             Ast::Expression initExpr = nullptr;
             if (isThis(TokenType::Assign))
@@ -305,7 +311,7 @@ namespace Fig
                 initExpr = parseExpression(0);
             }
             expectSemicolon();
-            return Ast::StructDefField(am, fieldName, tiName, initExpr);
+            return Ast::StructDefField(am, fieldName, fieldType, initExpr);
         };
         std::vector<Ast::Statement> stmts;
         std::vector<Ast::StructDefField> fields;
@@ -318,10 +324,7 @@ namespace Fig
                 next(); // consume `}`
                 break;
             }
-            if (isThis(TokenType::Identifier))
-            {
-                fields.push_back(__parseStructField(false));
-            }
+            if (isThis(TokenType::Identifier)) { fields.push_back(__parseStructField(false)); }
             else if (isThis(TokenType::Public))
             {
                 if (isNext(TokenType::Const))
@@ -361,23 +364,18 @@ namespace Fig
                 next(); // consume `struct`
                 stmts.push_back(__parseStructDef(false));
             }
-            else if (isThis(TokenType::Const))
-            {
-                fields.push_back(__parseStructField(false));
-            }
+            else if (isThis(TokenType::Const)) { fields.push_back(__parseStructField(false)); }
             else if (isThis(TokenType::Variable))
             {
-                throwAddressableError<SyntaxError>(FString("Variables are not allowed to be defined within a structure."));
+                throwAddressableError<SyntaxError>(
+                    FString("Variables are not allowed to be defined within a structure."));
             }
             else
             {
                 throwAddressableError<SyntaxError>(FString("Invalid syntax"));
             }
         }
-        if (!braceClosed)
-        {
-            throwAddressableError<SyntaxError>(FString("braces are not closed"));
-        }
+        if (!braceClosed) { throwAddressableError<SyntaxError>(FString("braces are not closed")); }
         return makeAst<Ast::StructDefSt>(isPublic, structName, fields, makeAst<Ast::BlockStatementAst>(stmts));
     }
 
@@ -409,31 +407,22 @@ namespace Fig
                 expect(TokenType::RightArrow); // ->
                 next();                        // consume `->`
 
-                expect(TokenType::Identifier, u8"return type");
-                FString returnType = currentToken().getValue();
-                next(); // consume return type
+                Ast::Expression returnType = parseExpression(0, TokenType::LeftBrace, TokenType::Semicolon);
 
                 if (isThis(TokenType::LeftBrace))
                 {
                     Ast::BlockStatement block = __parseBlockStatement();
 
-                    methods.push_back(Ast::InterfaceMethod(
-                        funcName,
-                        paras,
-                        returnType,
-                        block));
+                    methods.push_back(Ast::InterfaceMethod(funcName, paras, returnType, block));
                     continue;
                 }
                 expectSemicolon();
 
-                methods.push_back(Ast::InterfaceMethod(
-                    funcName,
-                    paras,
-                    returnType));
+                methods.push_back(Ast::InterfaceMethod(funcName, paras, returnType));
             }
             else
             {
-                throw SyntaxError(FString(u8"Invalid syntax"), currentAAI.line, currentAAI.column);
+                throwAddressableError<SyntaxError>(FString(u8"Invalid syntax"), currentAAI.line, currentAAI.column);
             }
         }
         return makeAst<Ast::InterfaceDefAst>(interfaceName, methods, isPublic);
@@ -454,7 +443,7 @@ namespace Fig
         FString structName = currentToken().getValue();
         next();                       // consume name
         expect(TokenType::LeftBrace); // {
-        next();  // consume `{`
+        next();                       // consume `{`
 
         std::vector<Ast::ImplementMethod> methods;
 
@@ -473,14 +462,11 @@ namespace Fig
                 Ast::FunctionParameters paras = __parseFunctionParameters();
                 expect(TokenType::LeftBrace);
                 Ast::BlockStatement body = __parseBlockStatement();
-                methods.push_back(Ast::ImplementMethod(
-                    funcName,
-                    paras,
-                    body));
+                methods.push_back(Ast::ImplementMethod(funcName, paras, body));
             }
             else
             {
-                throw SyntaxError(FString(u8"Invalid syntax"), currentAAI.line, currentAAI.column);
+                throwAddressableError<SyntaxError>(FString(u8"Invalid syntax"), currentAAI.line, currentAAI.column);
             }
         }
 
@@ -501,18 +487,18 @@ namespace Fig
     {
         // entry: current is `try`
         next(); // consume `try`
-        
+
         /*
         try
         {
-            ...        
+            ...
         }
         catch(e: IOError)
         {
         }
         catch(e: TimeOutError)
         {
-        } 
+        }
         */
         expect(TokenType::LeftBrace);
         Ast::BlockStatement body = __parseBlockStatement();
@@ -540,15 +526,13 @@ namespace Fig
                     hasType = true;
                 }
                 expect(TokenType::RightParen); // ）
-                next(); // consume `)`
-                expect(TokenType::LeftBrace); // {
+                next();                        // consume `)`
+                expect(TokenType::LeftBrace);  // {
                 Ast::BlockStatement catchBody = __parseBlockStatement();
 
-                if (hasType)
+                if (hasType) { catches.push_back(Ast::Catch(errVarName, errVarType, catchBody)); }
+                else
                 {
-                    catches.push_back(Ast::Catch(errVarName, errVarType, catchBody));
-                }
-                else {
                     catches.push_back(Ast::Catch(errVarName, catchBody));
                 }
             }
@@ -556,13 +540,14 @@ namespace Fig
             {
                 if (finallyBlock != nullptr)
                 {
-                    throw SyntaxError(u8"Duplicate try finally-block", currentAAI.line, currentAAI.column);
+                    throwAddressableError<SyntaxError>(
+                        u8"Duplicate try finally-block", currentAAI.line, currentAAI.column);
                 }
                 next(); // consume `finally`
                 expect(TokenType::LeftBrace);
                 finallyBlock = __parseBlockStatement();
             }
-            else 
+            else
             {
                 break;
             }
@@ -574,17 +559,11 @@ namespace Fig
     {
         Ast::Statement stmt;
         if (isThis(TokenType::EndOfFile)) { return makeAst<Ast::EofStmt>(); }
-        else if (isThis(TokenType::Import))
-        {
-            stmt = __parseImport();
-        }
+        else if (isThis(TokenType::Import)) { stmt = __parseImport(); }
         else if (isThis(TokenType::Public))
         {
             next(); // consume `public`
-            if (isThis(TokenType::Variable) || isThis(TokenType::Const))
-            {
-                stmt = __parseVarDef(true);
-            }
+            if (isThis(TokenType::Variable) || isThis(TokenType::Const)) { stmt = __parseVarDef(true); }
             else if (isThis(TokenType::Function) and isNext(TokenType::Identifier))
             {
                 next();
@@ -592,21 +571,17 @@ namespace Fig
             }
             else if (isThis(TokenType::Struct))
             {
+                next();
                 stmt = __parseStructDef(true);
             }
-            else if (isThis(TokenType::Interface))
-            {
-                stmt = __parseInterfaceDef(true);
-            }
+            else if (isThis(TokenType::Interface)) { stmt = __parseInterfaceDef(true); }
             else
             {
-                throwAddressableError<SyntaxError>(FString(u8"Expected `var`, `const`, `function`, `struct` or `interface` after `public`"));
+                throwAddressableError<SyntaxError>(
+                    FString(u8"Expected `var`, `const`, `function`, `struct` or `interface` after `public`"));
             }
         }
-        else if (isThis(TokenType::Variable) || isThis(TokenType::Const))
-        {
-            stmt = __parseVarDef(false);
-        }
+        else if (isThis(TokenType::Variable) || isThis(TokenType::Const)) { stmt = __parseVarDef(false); }
         else if (isThis(TokenType::Function) and isNext(TokenType::Identifier))
         {
             next();
@@ -624,50 +599,20 @@ namespace Fig
             next();
             stmt = __parseInterfaceDef(false);
         }
-        else if (isThis(TokenType::Implement))
-        {
-            stmt = __parseImplement();
-        }
-        else if (isThis(TokenType::If))
-        {
-            stmt = __parseIf();
-        }
+        else if (isThis(TokenType::Implement)) { stmt = __parseImplement(); }
+        else if (isThis(TokenType::If)) { stmt = __parseIf(); }
         else if (isThis(TokenType::Else))
         {
             throwAddressableError<SyntaxError>(FString(u8"`else` without matching `if`"));
         }
-        else if (isThis(TokenType::LeftBrace))
-        {
-            stmt = __parseBlockStatement();
-        }
-        else if (isThis(TokenType::While))
-        {
-            stmt = __parseWhile();
-        }
-        else if (isThis(TokenType::For))
-        {
-            stmt = __parseFor();
-        }
-        else if (isThis(TokenType::Return))
-        {
-            stmt = __parseReturn();
-        }
-        else if (isThis(TokenType::Break))
-        {
-            stmt = __parseBreak();
-        }
-        else if (isThis(TokenType::Continue))
-        {
-            stmt = __parseContinue();
-        }
-        else if (isThis(TokenType::Throw))
-        {
-            stmt = __parseThrow();
-        }
-        else if (isThis(TokenType::Try))
-        {
-            stmt = __parseTry();
-        }
+        else if (isThis(TokenType::LeftBrace)) { stmt = __parseBlockStatement(); }
+        else if (isThis(TokenType::While)) { stmt = __parseWhile(); }
+        else if (isThis(TokenType::For)) { stmt = __parseFor(); }
+        else if (isThis(TokenType::Return)) { stmt = __parseReturn(); }
+        else if (isThis(TokenType::Break)) { stmt = __parseBreak(); }
+        else if (isThis(TokenType::Continue)) { stmt = __parseContinue(); }
+        else if (isThis(TokenType::Throw)) { stmt = __parseThrow(); }
+        else if (isThis(TokenType::Try)) { stmt = __parseTry(); }
         else if (allowExp)
         {
             // expression statement
@@ -675,13 +620,9 @@ namespace Fig
             expectSemicolon();
             stmt = makeAst<Ast::ExpressionStmtAst>(exp);
         }
-        else 
+        else
         {
-            throw SyntaxError(
-                u8"invalid syntax",
-                currentAAI.line,
-                currentAAI.column
-            );
+            throwAddressableError<SyntaxError>(u8"invalid syntax", currentAAI.line, currentAAI.column);
         }
         return stmt;
     }
@@ -768,7 +709,7 @@ namespace Fig
         }
         else
         {
-            condition = parseExpression(0);
+            condition = parseExpression(0, TokenType::LeftBrace);
         }
         expect(TokenType::LeftBrace); // {
         Ast::BlockStatement body = __parseBlockStatement();
@@ -786,7 +727,8 @@ namespace Fig
             throwAddressableError<SyntaxError>(u8"BlockStatement cannot be used as for loop increment");
         }
 
-        if (isThis(TokenType::If) || isThis(TokenType::While) || isThis(TokenType::For) || isThis(TokenType::Return) || isThis(TokenType::Break) || isThis(TokenType::Continue))
+        if (isThis(TokenType::If) || isThis(TokenType::While) || isThis(TokenType::For) || isThis(TokenType::Return)
+            || isThis(TokenType::Break) || isThis(TokenType::Continue))
         {
             throwAddressableError<SyntaxError>(u8"Control flow statements cannot be used as for loop increment");
         }
@@ -801,8 +743,7 @@ namespace Fig
         // TODO: support enumeration
         next(); // consume `for`
         bool paren = isThis(TokenType::LeftParen);
-        if (paren)
-            next(); // consume `(`
+        if (paren) next(); // consume `(`
         // support 3-part for loop
         // for init; condition; increment {}
         Ast::Statement initStmt = __parseStatement(false); // auto check ``
@@ -815,8 +756,7 @@ namespace Fig
             // auto guard = disableSemicolon();
             incrementStmt = __parseIncrementStatement();
         } // after parse increment, semicolon check state restored
-        if (paren)
-            expectConsume(TokenType::RightParen);           // consume `)` if has `(`
+        if (paren) expectConsume(TokenType::RightParen);    // consume `)` if has `(`
         expect(TokenType::LeftBrace);                       // {
         Ast::BlockStatement body = __parseBlockStatement(); // auto consume `}`
         return makeAst<Ast::ForSt>(initStmt, condition, incrementStmt, body);
@@ -940,10 +880,7 @@ namespace Fig
         {
             if (mode == 0)
             {
-                if (isThis(TokenType::Identifier) && isNext(TokenType::Colon))
-                {
-                    mode = 2;
-                }
+                if (isThis(TokenType::Identifier) && isNext(TokenType::Colon)) { mode = 2; }
                 else if (isThis(TokenType::Identifier) && (isNext(TokenType::Comma) || isNext(TokenType::RightBrace)))
                 {
                     mode = 3;
@@ -987,17 +924,16 @@ namespace Fig
             }
             else if (!isThis(TokenType::RightBrace))
             {
-                throwAddressableError<SyntaxError>(FString(
-                    std::format("Expect `,` or `}}` in struct initialization expression, got {}",
-                                currentToken().toString().toBasicString())));
+                throwAddressableError<SyntaxError>(
+                    FString(std::format("Expect `,` or `}}` in struct initialization expression, got {}",
+                                        currentToken().toString().toBasicString())));
             }
         }
         expect(TokenType::RightBrace);
         next(); // consume `}`
-        return makeAst<Ast::InitExprAst>(structe, args,
-                                         (mode == 1 ? Ast::InitExprAst::InitMode::Positional :
-                                                      (mode == 2 ? Ast::InitExprAst::InitMode::Named : Ast::InitExprAst::InitMode::Shorthand)));
+        return makeAst<Ast::InitExprAst>(structe, args, static_cast<Ast::InitExprAst::InitMode>(mode));
     }
+
     Ast::Expression Parser::__parseTupleOrParenExpr()
     {
         next();
@@ -1019,8 +955,7 @@ namespace Fig
             {
                 next(); // consume ','
 
-                if (currentToken().getType() == TokenType::RightParen)
-                    break;
+                if (currentToken().getType() == TokenType::RightParen) break;
 
                 elements.push_back(parseExpression(0));
             }
@@ -1066,37 +1001,63 @@ namespace Fig
     {
         next(); // consume `import`
         std::vector<FString> path;
+        std::vector<FString> names;
+        FString rename;
         while (true)
         {
             expect(TokenType::Identifier, u8"package name");
             path.push_back(currentToken().getValue());
             next(); // consume package name
-            if (isThis(TokenType::Semicolon))
-            {
-                break;
-            }
+            if (isThis(TokenType::Semicolon)) { break; }
             else if (isThis(TokenType::Dot))
             {
                 next(); // consume `.`
             }
+            else if (isThis(TokenType::As)) { break; }
+            else if (isThis(TokenType::LeftBrace)) { break; }
             else
             {
-                throw SyntaxError();
+                throwAddressableError<SyntaxError>(u8"invalid syntax");
+            }
+        }
+        if (isThis(TokenType::As))
+        {
+            next(); // consume `as`
+            expect(TokenType::Identifier, u8"new name");
+            rename = currentToken().getValue();
+            next(); // consume name
+        }
+        else if (isThis(TokenType::LeftBrace))
+        {
+            next(); // consume `{`
+            while (true)
+            {
+                if (isThis(TokenType::RightBrace))
+                {
+                    next(); // consume `}`
+                    break;
+                }
+                if (isThis(TokenType::Comma))
+                {
+                    next(); // consume `,`
+                }
+                expect(TokenType::Identifier, u8"symbol name");
+                names.push_back(currentToken().getValue());
+                next();
             }
         }
         expectSemicolon();
-        return makeAst<Ast::ImportSt>(path);
+        return makeAst<Ast::ImportSt>(path, names, rename);
     }
 
-    Ast::Expression Parser::parseExpression(Precedence bp, TokenType stop, TokenType stop2)
+    Ast::Expression Parser::parseExpression(Precedence bp, TokenType stop, TokenType stop2, TokenType stop3)
     {
         Ast::Expression lhs;
         Ast::Operator op;
 
         Token tok = currentToken();
-        if (tok == EOFTok)
-            throwAddressableError<SyntaxError>(FString(u8"Unexpected end of expression"));
-        if (tok.getType() == stop || tok.getType() == stop2)
+        if (tok == EOFTok) throwAddressableError<SyntaxError>(FString(u8"Unexpected end of expression"));
+        if (tok.getType() == stop || tok.getType() == stop2 || tok.getType() == stop3)
         {
             if (lhs == nullptr) throwAddressableError<SyntaxError>(FString(u8"Expected expression"));
             return lhs;
@@ -1141,6 +1102,14 @@ namespace Fig
             next();
             lhs = makeAst<Ast::UnaryExprAst>(op, parseExpression(bp, stop, stop2));
         }
+        else if (tok.getType() == TokenType::New)
+        {
+            // `new` now is an independent syntax
+            next();
+            Ast::Expression operand = parseExpression(bp, TokenType::LeftBrace);
+            expect(TokenType::LeftBrace);
+            lhs = __parseInitExpr(operand);
+        }
         else
         {
             throwAddressableError<SyntaxError>(FString(u8"Unexpected token in expression:") + tok.toString());
@@ -1150,21 +1119,31 @@ namespace Fig
         while (true)
         {
             tok = currentToken();
-            if (tok.getType() == stop || tok.getType() == stop2|| tok == EOFTok) break;
+            if (tok.getType() == stop || tok.getType() == stop2 || tok.getType() == stop3 || tok == EOFTok) break;
 
             /* Postfix */
 
+            if (tok.getType() == TokenType::LeftBrace)
+            {
+                throwAddressableError<SyntaxError>(
+                    FString(u8"Since Fig v0.4.2, please use new struct{} to avoid syntax ambiguity"));
+            }
+
             if (tok.getType() == TokenType::LeftParen)
             {
                 lhs = __parseCall(lhs);
                 continue;
             }
+            // else if (tok.getType() == TokenType::LeftBrace) { lhs = __parseInitExpr(lhs); }
+            /*
+                since Fig v0.4.2, use new struct{};
 
-            if (tok.getType() == TokenType::LeftBrace)
-            {
-                lhs = __parseInitExpr(lhs);
-                continue;
-            }
+                if a == A{}
+                is A{} struct init?
+                or A a variable, {} is the body?
+
+                fuck.
+            */
 
             // member access: a.b
             if (tok.getType() == TokenType::Dot)
@@ -1191,15 +1170,17 @@ namespace Fig
                 lhs = makeAst<Ast::IndexExprAst>(lhs, indexExpr);
                 continue;
             }
-
             // ternary
             if (tok.getType() == TokenType::Question)
             {
+                auto [lbp, rbp] = getBindingPower(Ast::Operator::TernaryCond);
+                if (bp >= lbp) break;
+
                 next(); // consume ?
-                Ast::Expression trueExpr = parseExpression(0, TokenType::Colon, stop2);
-                expect(TokenType::Colon);
-                next(); // consume :
-                Ast::Expression falseExpr = parseExpression(0, TokenType::Semicolon, stop2);
+                Ast::Expression trueExpr = parseExpression(0, TokenType::Colon);
+                expectConsume(TokenType::Colon);
+
+                Ast::Expression falseExpr = parseExpression(0);
                 lhs = makeAst<Ast::TernaryExprAst>(lhs, trueExpr, falseExpr);
                 continue;
             }
@@ -1207,11 +1188,11 @@ namespace Fig
             if (!isTokenOp(tok)) break;
 
             op = Ast::TokenToOp.at(tok.getType());
-            Precedence lbp = getLeftBindingPower(op);
+            auto [lbp, rbp] = getBindingPower(op);
             if (bp >= lbp) break;
 
             next(); // consume op
-            lhs = makeAst<Ast::BinaryExprAst>(lhs, op, parseExpression(bp, stop, stop2));
+            lhs = makeAst<Ast::BinaryExprAst>(lhs, op, parseExpression(rbp, stop, stop2));
         }
 
         return lhs;
@@ -1221,20 +1202,15 @@ namespace Fig
     {
         output.clear();
         Token tok = currentToken();
-        if (tok == EOFTok)
-        {
-            return output;
-        }
+        if (tok == EOFTok) { return output; }
 
         while (!isEOF())
         {
             auto stmt = __parseStatement();
             if (!output.empty() && stmt->getType() == Ast::AstType::PackageSt)
             {
-                throw SyntaxError(
-                    u8"Package must be at the beginning of the file",
-                    currentAAI.line,
-                    currentAAI.column);
+                throwAddressableError<SyntaxError>(
+                    u8"Package must be at the beginning of the file", currentAAI.line, currentAAI.column);
             }
             pushNode(stmt);
         }

src/Parser/parser.hpp

@@ -1,12 +1,13 @@
 #pragma once
 
-#include "Ast/astBase.hpp"
+#include <Token/token.hpp>
+#include <Ast/astBase.hpp>
 #include <Ast/ast.hpp>
 #include <Lexer/lexer.hpp>
 #include <Core/fig_string.hpp>
 #include <Error/error.hpp>
 
-#include <print>
+#include <memory>
 #include <source_location>
 #include <unordered_map>
 
@@ -22,6 +23,9 @@ namespace Fig
         std::vector<Ast::AstBase> output;
         std::vector<Token> previousTokens;
 
+        std::shared_ptr<FString> sourcePathPtr;
+        std::shared_ptr<std::vector<FString>> sourceLinesPtr;
+
         size_t tokenPruduced = 0;
         size_t currentTokenIndex = 0;
 
@@ -72,7 +76,11 @@ namespace Fig
         static const std::unordered_map<Ast::Operator, std::pair<Precedence, Precedence>> opPrecedence;
         static const std::unordered_map<Ast::Operator, Precedence> unaryOpPrecedence;
 
-        Parser(const Lexer &_lexer) : lexer(_lexer) {}
+        Parser(const Lexer &_lexer, FString _sourcePath, std::vector<FString> _sourceLines) : lexer(_lexer)
+        {
+            sourcePathPtr = std::make_shared<FString>(_sourcePath);
+            sourceLinesPtr = std::make_shared<std::vector<FString>>(_sourceLines);
+        }
 
         AddressableError *getError() const { return error.get(); }
 
@@ -83,7 +91,7 @@ namespace Fig
                                    std::source_location loc = std::source_location::current())
         {
             static_assert(std::is_base_of_v<AddressableError, _ErrT>, "_ErrT must derive from AddressableError");
-            _ErrT spError(msg, line, column, loc);
+            _ErrT spError(msg, line, column, *sourcePathPtr, *sourceLinesPtr, loc);
             error = std::make_unique<_ErrT>(spError);
             throw spError;
         }
@@ -92,7 +100,7 @@ namespace Fig
         {
             static_assert(std::is_base_of_v<AddressableError, _ErrT>, "_ErrT must derive from AddressableError");
             // line, column provide by `currentAAI`
-            _ErrT spError(msg, currentAAI.line, currentAAI.column, loc);
+            _ErrT spError(msg, currentAAI.line, currentAAI.column, *sourcePathPtr, *sourceLinesPtr, loc);
             error = std::make_unique<_ErrT>(spError);
             throw spError;
         }
@@ -135,7 +143,10 @@ namespace Fig
                 CTI也需要显示转换，否则转换完的pruduced又会被转回去，变为 int64_t max
                 */
                 currentTokenIndex++;
-                setCurrentAAI(Ast::AstAddressInfo{.line = currentToken().line, .column = currentToken().column});
+                setCurrentAAI(Ast::AstAddressInfo{.line = currentToken().line,
+                                                  .column = currentToken().column,
+                                                  .sourcePath = sourcePathPtr,
+                                                  .sourceLines = sourceLinesPtr});
                 return;
             }
             if (isEOF()) return;
@@ -143,7 +154,9 @@ namespace Fig
             tokenPruduced++;
             if (tok == IllegalTok) throw lexer.getError();
             currentTokenIndex = tokenPruduced - 1;
-            setCurrentAAI(Ast::AstAddressInfo{.line = tok.line, .column = tok.column});
+            setCurrentAAI(Ast::AstAddressInfo{
+                .line = tok.line, .column = tok.column, .sourcePath = sourcePathPtr, .sourceLines = sourceLinesPtr});
+
             previousTokens.push_back(tok);
         }
         inline const Token &currentToken()
@@ -233,7 +246,7 @@ namespace Fig
 
         [[nodiscard]] SemicolonDisabler disableSemicolon() { return SemicolonDisabler(this); }
 
-        void expectSemicolon()
+        void expectSemicolon(std::source_location loc = std::source_location::current())
         {
             // if need semicolon and stream has `;`, consume it. if not need semicolon, do nothing
 
@@ -248,18 +261,18 @@ namespace Fig
             }
 
             // normal semicolon check
-            expectConsume(TokenType::Semicolon);
+            expectConsume(TokenType::Semicolon, loc);
         }
 
-        void expectConsume(TokenType type, FString expected)
+        void expectConsume(TokenType type, FString expected, std::source_location loc = std::source_location::current())
         {
-            expect(type, expected);
+            expect(type, expected, loc);
             next();
         }
 
-        void expectConsume(TokenType type)
+        void expectConsume(TokenType type, std::source_location loc = std::source_location::current())
         {
-            expect(type);
+            expect(type, loc);
             next();
         }
 
@@ -298,8 +311,8 @@ namespace Fig
         Ast::ListExpr __parseListExpr(); // entry: current is `[`
         Ast::MapExpr __parseMapExpr();   // entry: current is `{`
 
-        Ast::InitExpr __parseInitExpr(
-            Ast::Expression); // entry: current is `{`, ahead is struct type exp.
+        Ast::InitExpr __parseInitExpr(Ast::Expression); // entry: current is `{`, ahead is struct type exp.
+
         Ast::Expression __parseTupleOrParenExpr(); // entry: current is `(`
 
         Ast::FunctionLiteralExpr __parseFunctionLiteralExpr(); // entry: current is Token::LParen after Token::Function
@@ -307,7 +320,10 @@ namespace Fig
         Ast::Import __parseImport(); // entry: current is Token::Import
 
         Ast::Statement __parseStatement(bool = true); // entry: (idk)
-        Ast::Expression parseExpression(Precedence, TokenType = TokenType::Semicolon, TokenType = TokenType::Semicolon);
+        Ast::Expression parseExpression(Precedence,
+                                        TokenType = TokenType::Semicolon,
+                                        TokenType = TokenType::Semicolon,
+                                        TokenType = TokenType::Semicolon);
         std::vector<Ast::AstBase> parseAll();
     };
 }; // namespace Fig

src/Repl/Repl.cpp

@@ -0,0 +1,62 @@
+#include <Ast/astBase.hpp>
+#include <Error/error.hpp>
+#include <Error/errorLog.hpp>
+#include <Core/fig_string.hpp>
+#include <Repl/Repl.hpp>
+#include <vector>
+
+namespace Fig
+{
+    void Repl::Start() const
+    {
+        ostream << getPrompt() << "\n";
+
+        const FString &sourcePath = u8"<stdin>";
+        const std::vector<FString> &sourceLines{};
+
+        Evaluator evaluator;
+
+        evaluator.CreateGlobalContext();
+        evaluator.RegisterBuiltinsValue();
+        evaluator.SetSourcePath(sourcePath);
+        evaluator.SetSourceLines(sourceLines);
+
+        while (true)
+        {
+            ostream << "\r\n>>";
+            const FString &line = readline();
+
+            if (line.empty())
+            {
+                ostream << Object::getNullInstance()->toString().toBasicString();
+                continue;
+            }
+            if (line == u8"!exit") { break; }
+
+            Lexer lexer(line, sourcePath, sourceLines);
+            Parser parser(lexer, sourcePath, sourceLines);
+
+            std::vector<AstBase> program;
+            try
+            {
+                program = parser.parseAll();
+
+                StatementResult sr = evaluator.Run(program);
+                ObjectPtr result = sr.result;
+                ostream << result->toString().toBasicString() << '\n';
+            }
+            catch (AddressableError &e)
+            {
+                ostream << "Oops!\n";
+                ErrorLog::logAddressableError(e);
+                ostream << "\n";
+            }
+            catch (UnaddressableError &e)
+            {
+                ostream << "Oops!\n";
+                ErrorLog::logUnaddressableError(e);
+                ostream << "\n";
+            }
+        }
+    }
+} // namespace Fig

src/Repl/Repl.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <Core/core.hpp>
+#include <Lexer/lexer.hpp>
+#include <Parser/parser.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Utils/AstPrinter.hpp>
+#include <Utils/utils.hpp>
+#include <Error/errorLog.hpp>
+#include <Core/runtimeTime.hpp>
+
+#include <format>
+#include <iostream>
+#include <ostream>
+#include <string>
+
+namespace Fig
+{
+    class Repl
+    {
+    private:
+        std::istream &istream;
+        std::ostream &ostream;
+
+    public:
+        Repl(std::istream &_istream = std::cin, std::ostream &_ostream = std::cout) :
+            istream(_istream), ostream(_ostream)
+        {
+        }
+
+        FString readline() const
+        {
+            std::string buf;
+            std::getline(istream, buf);
+
+            return FString(buf);
+        }
+
+        static std::string getPrompt()
+        {
+            static const std::string prompt = std::format("Fig {} ({})[{} {}-bit on `{}`]\n",
+                                                          Core::VERSION,
+                                                          Core::COMPILE_TIME,
+                                                          Core::COMPILER,
+                                                          Core::ARCH,
+                                                          Core::PLATFORM)
+                                              + "Type '!exit' to exit\n" + "feel free to type!";
+            return prompt;
+        }
+
+        void Start() const;
+    };
+
+}; // namespace Fig

src/Token/token.hpp

@@ -31,6 +31,7 @@ namespace Fig
         For,       // for
         If,        // if
         Else,      // else
+        New,       // new
         Struct,    // struct
         Interface, // interface
         Implement, // impl
@@ -43,6 +44,7 @@ namespace Fig
         Catch,     // catch
         Throw,     // throw
         Finally,   // finally
+        As,        // as
 
         // TypeNull,   // Null
         // TypeInt,    // Int

src/Utils/AstPrinter.hpp

@@ -111,7 +111,7 @@ private:
         printFString(node->name, 0);
         printIndent(indent + 2);
         std::cout << "Type: ";
-        printFString(node->typeName, 0);
+        printFString(node->declaredType->toString(), 0);
         if (node->expr)
         {
             printIndent(indent + 2);

src/VMValue/VMValue.cpp

@@ -1,29 +0,0 @@
-#include <VMValue/VMValue.hpp>
-
-#include <cassert>
-#include <string>
-
-namespace Fig
-{
-    FString Value::toString() const
-    {
-        if (static_cast<int>(type) > static_cast<int>(Double))
-        {
-            return heap->toString();
-        }
-        switch (type)
-        {
-            case Null:
-                return u8"null";
-            case Bool:
-                return (b ? u8"true" : u8"false");
-            case Int:
-                return FString(std::to_string(i));
-            case Double:
-                return FString(std::to_string(d));
-            
-            default:
-                assert(false);
-        }
-    }
-};

src/VMValue/VMValue.hpp

@@ -1,91 +0,0 @@
-#pragma once
-
-/*
-    value system for virtual machine
-    not Evaluator value
-*/
-
-#include <Core/fig_string.hpp>
-
-#include <cstdint>
-
-namespace Fig
-{
-    struct HeapObject;
-
-    struct Value
-    {
-        struct NullObject {};
-
-        enum _Type : uint8_t
-        {
-            Null = 0,
-            Bool,
-            Int,
-            Double,
-
-            /* Complex types, alloc in heap*/
-            String,
-            // Function,
-            // StructType,
-            // StructInstance,
-            // List,
-            // Map,
-            // Module,
-            // InterfaceType
-        } type;
-        
-        union
-        {
-            NullObject n;
-            bool b;
-            int64_t i;
-            double d;
-
-            HeapObject *heap;
-        };
-
-        Value()
-        {
-            type = Null;
-            n = NullObject();
-        }
-
-        Value(bool _b)
-        {
-            type = Bool;
-            b = _b;
-        }
-
-        Value(int64_t _i)
-        {
-            type = Int;
-            i = _i;
-        }
-
-        Value(double _d)
-        {
-            type = Double;
-            d = _d;
-        }
-
-        FString toString() const;
-    };
-
-    struct HeapObject
-    {
-        Value::_Type type; // > 3
-
-        virtual FString toString() const = 0;
-    };
-
-    struct String : HeapObject
-    {
-        FString value;
-
-        virtual FString toString() const override
-        {
-            return value;
-        }
-    };
-};

src/VirtualMachine/VirtualMachine.cpp

@@ -0,0 +1,225 @@
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/Type.hpp>
+
+#include <Bytecode/Instruction.hpp>
+#include <Bytecode/CompiledFunction.hpp>
+#include <VirtualMachine/VirtualMachine.hpp>
+
+namespace Fig
+{
+    Object VirtualMachine::Execute()
+    {
+        while (currentFrame->ip < currentFrame->fn.chunk.ins.size())
+        {
+            Instruction ins = currentFrame->fn.chunk.ins[currentFrame->ip++];
+
+            switch (ins.code)
+            {
+                case OpCode::HALT: {
+                    return *Object::getNullInstance();
+                }
+                case OpCode::RETURN: {
+                    const Object &ret = pop();
+
+                    uint64_t base = currentFrame->base;
+                    popFrame();
+
+                    if (frames.empty())
+                    {
+                        return ret;
+                    }
+
+                    stack.resize(base); // 清除函数的临时值
+                    push(ret);
+                    break;
+                }
+                case OpCode::LOAD_LOCAL: {
+                    uint64_t operand = static_cast<uint64_t>(ins.operand);
+                    // LOCAL编号都为正数
+
+                    push(stack[currentFrame->base + operand]);
+                    break;
+                }
+
+                case OpCode::LOAD_CONST: {
+                    uint64_t operand = static_cast<uint64_t>(ins.operand);
+                    // CONST编号都为正数
+
+                    push(currentFrame->fn.chunk.constants[operand]);
+                    break;
+                }
+
+                case OpCode::STORE_LOCAL: {
+                    uint64_t operand = static_cast<uint64_t>(ins.operand);
+                    // LOCAL编号都为正数
+
+                    stack[currentFrame->base + operand] = pop();
+                    break;
+                }
+
+                case OpCode::LT: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    Object result = lhs < rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::LTET: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    Object result = lhs <= rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::GT: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    Object result = lhs > rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::GTET: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    Object result = lhs >= rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::ADD: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    if (lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs.as<ValueType::IntClass>() + rhs.as<ValueType::IntClass>();
+                        push(Object(result));
+                        break;
+                    }
+
+                    Object result = lhs + rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::SUB: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    if (lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs.as<ValueType::IntClass>() - rhs.as<ValueType::IntClass>();
+                        push(Object(result));
+                        break;
+                    }
+
+                    Object result = lhs - rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::MUL: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    if (lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>())
+                    {
+                        ValueType::IntClass result = lhs.as<ValueType::IntClass>() * rhs.as<ValueType::IntClass>();
+                        push(Object(result));
+                        break;
+                    }
+
+                    Object result = lhs * rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::DIV: {
+                    const Object &rhs = pop();
+                    const Object &lhs = pop();
+
+                    if (lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>())
+                    {
+                        ValueType::DoubleClass result = (double)lhs.as<ValueType::IntClass>() / (double)rhs.as<ValueType::IntClass>();
+                        push(Object(result));
+                        break;
+                    }
+
+                    Object result = lhs / rhs;
+                    push(result);
+                    break;
+                }
+
+                case OpCode::JUMP: {
+                    int64_t target = ins.operand;
+                    currentFrame->ip += target;
+                    break;
+                }
+
+                case OpCode::JUMP_IF_FALSE: {
+                    const Object &cond = pop();
+
+                    if (!cond.is<bool>())
+                    {
+                        throw RuntimeError(
+                            FString(u8"Condition must be boolean!")
+                        );
+                    }
+                    if (!cond.as<bool>())
+                    {
+                        // cond is falsity
+                        int64_t target = ins.operand;
+                        currentFrame->ip += target;
+                    }
+                    break;
+                }
+
+                case OpCode::CALL:
+                {
+                    uint16_t argCount = static_cast<uint16_t>(ins.operand); // number of max arg is UINT16_MAX
+                    
+                    const Object &obj = stack.back();
+                    if (!obj.is<Function>())
+                    {
+                        throw RuntimeError(FString(std::format("{} is not callable", obj.toString().toBasicString())));
+                    }
+
+                    // const Function &fn_obj = obj.as<Function>();
+                    // assert(fn_obj.isCompiled && "function must be compiled");
+                    
+                    CompiledFunction fn;
+
+                    assert(stack.size() >= argCount && "stack does not have enough arguments");
+                    assert(fn.slotCount >= argCount && "slotCount < argCount");
+
+                    uint64_t base = stack.size() - 1 - argCount;
+
+                    pop(); // pop function
+
+                    for (int64_t i = 0; i < fn.slotCount - argCount; ++i)
+                    {
+                        push(*Object::getNullInstance());
+                    }
+
+                    CallFrame newFrame 
+                    {
+                        0,
+                        base, // 参数已经加载到stack, base为第一个参数
+                        fn
+                    };
+
+                    addFrame(newFrame);
+                    break;
+                }
+            }
+        }
+        return *Object::getNullInstance();
+    }
+}; // namespace Fig

src/VirtualMachine/VirtualMachine.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <Evaluator/Value/value.hpp>
+#include <Bytecode/CallFrame.hpp>
+
+#include <vector>
+
+namespace Fig
+{
+    class VirtualMachine
+    {
+    private:
+        std::vector<CallFrame> frames;
+        CallFrame *currentFrame;
+
+        std::vector<Object> stack;
+        Object *stack_top;
+
+    public:
+        void Clean()
+        {
+            frames.clear();
+            stack.clear();
+
+            currentFrame = nullptr;
+            stack_top = nullptr;
+        }
+
+        void addFrame(const CallFrame &_frame)
+        {
+            frames.push_back(_frame);
+            currentFrame = &frames.back();
+        }
+
+        CallFrame popFrame()
+        {
+            assert((!frames.empty()) && "frames is empty!");
+
+            CallFrame back = *currentFrame;
+            frames.pop_back();
+            currentFrame = (frames.empty() ? nullptr : &frames.back());
+
+            return back;
+        }
+
+        void push(const Object &_object)
+        {
+            stack.push_back(_object);
+            stack_top = &stack.back();
+        }
+
+        void nextIns(CallFrame &frame) const
+        {
+            frame.ip += 1;
+        }
+
+        Object pop()
+        {
+            assert((!stack.empty()) && "stack is empty!");
+
+            Object back = *stack_top;
+            stack.pop_back();
+            stack_top = (stack.empty() ? nullptr : &stack.back());
+
+            return back;
+        }
+
+        VirtualMachine(const CallFrame &_frame) 
+        {
+            addFrame(_frame);
+        }
+
+        Object Execute();
+    };
+};

src/VirtualMachine/main.cpp

@@ -1,43 +0,0 @@
-/*
-
- ███████████ █████   █████ ██████████    ███████████ █████   █████████     █████         █████████   ██████   █████   █████████  █████  █████   █████████     █████████  ██████████
-░█░░░███░░░█░░███   ░░███ ░░███░░░░░█   ░░███░░░░░░█░░███   ███░░░░░███   ░░███         ███░░░░░███ ░░██████ ░░███   ███░░░░░███░░███  ░░███   ███░░░░░███   ███░░░░░███░░███░░░░░█
-░   ░███  ░  ░███    ░███  ░███  █ ░     ░███   █ ░  ░███  ███     ░░░     ░███        ░███    ░███  ░███░███ ░███  ███     ░░░  ░███   ░███  ░███    ░███  ███     ░░░  ░███  █ ░
-    ░███     ░███████████  ░██████       ░███████    ░███ ░███             ░███        ░███████████  ░███░░███░███ ░███          ░███   ░███  ░███████████ ░███          ░██████
-    ░███     ░███░░░░░███  ░███░░█       ░███░░░█    ░███ ░███    █████    ░███        ░███░░░░░███  ░███ ░░██████ ░███    █████ ░███   ░███  ░███░░░░░███ ░███    █████ ░███░░█
-    ░███     ░███    ░███  ░███ ░   █    ░███  ░     ░███ ░░███  ░░███     ░███      █ ░███    ░███  ░███  ░░█████ ░░███  ░░███  ░███   ░███  ░███    ░███ ░░███  ░░███  ░███ ░   █
-    █████    █████   █████ ██████████    █████       █████ ░░█████████     ███████████ █████   █████ █████  ░░█████ ░░█████████  ░░████████   █████   █████ ░░█████████  ██████████
-   ░░░░░    ░░░░░   ░░░░░ ░░░░░░░░░░    ░░░░░       ░░░░░   ░░░░░░░░░     ░░░░░░░░░░░ ░░░░░   ░░░░░ ░░░░░    ░░░░░   ░░░░░░░░░    ░░░░░░░░   ░░░░░   ░░░░░   ░░░░░░░░░  ░░░░░░░░░░
-
-   Copyright (C) 2020-2026 PuqiAR
-
-This software is licensed under the MIT License. See LICENSE for details.
-*/
-
-
-// DO NOT USE CLANG-FORMAT FOR THIS FILE
-
-#include <Bytecode/Bytecode.hpp>
-#include <iostream>
-
-int main()
-{
-    using namespace Fig;
-
-
-    std::vector<OpCodeType> src;
-    
-    {
-        using enum Bytecode;
-        src = {
-            0x21, // LOAD_TRUE
-            0x23, 0x7f, // LOAD_CON8 0x7f
-            0x24, 0x12, 0x34, // LOAD_CON16 0x1234
-            0x25, 0x12, 0x34, 0x56, 0x78, // LOAD_CON32 0x12345678
-            0x63, 0x12, 0x34, 0x56, 0x78 // JUMP32_IF_TRUE
-        };
-
-        FString r = reverseCompile(src);
-        std::cout << r.toBasicString() << std::endl;
-    }
-}

src/main.cpp

@@ -28,7 +28,7 @@ This software is licensed under the MIT License. See LICENSE.txt for details.
 */
 
 #include <Utils/argparse/argparse.hpp>
-#include <print>
+// #include <print>
 #include <fstream>
 
 #include <Core/core.hpp>
@@ -38,6 +38,8 @@ This software is licensed under the MIT License. See LICENSE.txt for details.
 #include <Utils/AstPrinter.hpp>
 #include <Utils/utils.hpp>
 #include <Error/errorLog.hpp>
+#include <Core/runtimeTime.hpp>
+#include <Repl/Repl.hpp>
 
 static size_t addressableErrorCount = 0;
 static size_t unaddressableErrorCount = 0;
@@ -45,10 +47,18 @@ static size_t unaddressableErrorCount = 0;
 
 int main(int argc, char **argv)
 {
+    Time::init();
+    // init, set start_time (std::chrono::time_point)
+
+
     argparse::ArgumentParser program("Fig Interpreter", Fig::Core::VERSION.data());
     program.add_argument("source")
         .help("source file to be interpreted")
         .default_value(std::string(""));
+    program.add_argument("-r", "--repl")
+        .help("start repl")
+        .default_value(false)
+        .implicit_value(true);
     // program.add_argument("-v", "--version")
     //     .help("get the version of Fig Interpreter")
     //     .default_value(false)
@@ -69,6 +79,14 @@ int main(int argc, char **argv)
     //     std::print("Fig Interpreter version {}\n", Fig::Core::VERSION);
     //     return 0;
     // }
+
+    if (program.get<bool>("--repl"))
+    {
+        Fig::Repl repl;
+        repl.Start();
+        exit(0);
+    }
+
     Fig::FString sourcePath(program.get<std::string>("source"));
     if (sourcePath.empty())
     {
@@ -84,7 +102,9 @@ int main(int argc, char **argv)
     std::string source((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
     file.close();
 
-    Fig::Lexer lexer((Fig::FString(source)));
+    std::vector<FString> sourceLines = Fig::Utils::splitSource(Fig::FString(source));
+
+    Fig::Lexer lexer((Fig::FString(source)), sourcePath, sourceLines);
 
     // Token tok;
     // while ((tok = lexer.nextToken()).getType() != TokenType::EndOfFile)
@@ -92,11 +112,9 @@ int main(int argc, char **argv)
     //     std::println("{}", tok.toString().toBasicString());
     // }
 
-    Fig::Parser parser(lexer);
+    Fig::Parser parser(lexer, sourcePath, sourceLines);
     std::vector<Fig::Ast::AstBase> asts;
 
-    std::vector<FString> sourceLines = Fig::Utils::splitSource(Fig::FString(source));
-
     try
     {
         asts = parser.parseAll();
@@ -104,7 +122,7 @@ int main(int argc, char **argv)
     catch (const Fig::AddressableError &e)
     {
         addressableErrorCount++;
-        ErrorLog::logAddressableError(e, sourcePath, sourceLines);
+        ErrorLog::logAddressableError(e);
         return 1;
     }
     catch (const Fig::UnaddressableError &e)
@@ -129,6 +147,7 @@ int main(int argc, char **argv)
     Fig::Evaluator evaluator;
 
     evaluator.SetSourcePath(sourcePath);
+    evaluator.SetSourceLines(sourceLines);
     evaluator.CreateGlobalContext();
     evaluator.RegisterBuiltinsValue(); 
 
@@ -139,7 +158,7 @@ int main(int argc, char **argv)
     catch (const Fig::AddressableError &e)
     {
         addressableErrorCount++;
-        ErrorLog::logAddressableError(e, sourcePath, sourceLines);
+        ErrorLog::logAddressableError(e);
         evaluator.printStackTrace();
         return 1;
     }

xmake.lua

@@ -3,74 +3,63 @@ add_rules("plugin.compile_commands.autoupdate", {outputdir = ".vscode"})
 
 set_policy("run.autobuild", false)
 
+set_languages("c++23")
+
+add_ldflags("-static", {force = true})
+if is_plat("linux") then
+    -- Linux: clang + libc++
+    set_toolchains("clang")
+    add_cxxflags("-stdlib=libc++")
+    add_ldflags("-stdlib=libc++")
+elseif is_plat("windows") then
+    -- 1. CI cross (Linux -> Windows)
+    -- 2. local dev (Windows + llvm-mingw)
+    set_toolchains("mingw") -- llvm-mingw
+    add_ldflags("-Wl,--stack,268435456")
+    -- set_toolchains("clang")
+    -- static lib
+    -- add_ldflags("-target x86_64-w64-mingw32", "-static")
+    -- add_cxxflags("-stdlib=libc++")
+    -- add_ldflags("-stdlib=libc++")
+end
+    
+
+
+add_files("src/Core/warning.cpp")
+add_files("src/Core/runtimeTime.cpp")
+
+add_files("src/Lexer/lexer.cpp")
+add_files("src/Parser/parser.cpp")
+
+add_files("src/Module/builtins.cpp")
+
+add_files("src/Evaluator/Value/value.cpp")
+add_includedirs("src")
+
+add_defines("__FCORE_COMPILE_TIME=\"" .. os.date("%Y-%m-%d %H:%M:%S") .. "\"")
+
 target("Fig")
     set_kind("binary")
-    set_languages("c++23")
 
-    add_ldflags("-static", {force = true})
-    if is_plat("linux") then
-        -- Linux: clang + libc++
-        set_toolchains("clang")
-        add_cxxflags("-stdlib=libc++")
-        add_ldflags("-stdlib=libc++")
-    elseif is_plat("windows") then
-        -- 1. CI cross (Linux -> Windows)
-        -- 2. local dev (Windows + llvm-mingw)
-        set_toolchains("mingw") -- llvm-mingw
-        add_ldflags("-Wl,--stack,268435456")
-        -- set_toolchains("clang")
-        -- static lib
-        -- add_ldflags("-target x86_64-w64-mingw32", "-static")
-        -- add_cxxflags("-stdlib=libc++")
-        -- add_ldflags("-stdlib=libc++")
-    end
-    
-
-    add_files("src/Evaluator/main.cpp")
-    add_files("src/Core/warning.cpp")
+    add_files("src/Evaluator/Core/*.cpp")
+    add_files("src/VirtualMachine/VirtualMachine.cpp")
     add_files("src/Evaluator/evaluator.cpp")
-    add_files("src/Evaluator/Value/value.cpp")
-    add_files("src/Lexer/lexer.cpp")
-    add_files("src/Parser/parser.cpp")
-
-    add_includedirs("src")
-    add_includedirs("src/Evaluator")
-
+    add_files("src/Repl/Repl.cpp")
+    add_files("src/main.cpp")
+    
     set_warnings("all")
 
-    add_defines("__FCORE_COMPILE_TIME=\"" .. os.date("%Y-%m-%d %H:%M:%S") .. "\"")
+target("vm_test_main")
+    set_kind("binary")
 
--- -- Bytecode VM target
--- target("Figc")
---     set_kind("binary")
---     set_languages("c++23")
-
---     add_ldflags("-static", {force = true})
---     if is_plat("linux") then
---         -- Linux: clang + libc++
---         set_toolchains("clang")
---         add_cxxflags("-stdlib=libc++")
---         add_ldflags("-stdlib=libc++")
---     elseif is_plat("windows") then
---         -- 1. CI cross (Linux -> Windows)
---         -- 2. local dev (Windows + llvm-mingw)
---         set_toolchains("mingw") -- llvm-mingw
---         add_ldflags("-Wl,--stack,268435456")
---         -- set_toolchains("clang")
---         -- static lib
---         -- add_ldflags("-target x86_64-w64-mingw32", "-static")
---         -- add_cxxflags("-stdlib=libc++")
---         -- add_ldflags("-stdlib=libc++")
---     end
+    add_files("src/VirtualMachine/VirtualMachine.cpp")
+    add_files("src/Bytecode/vm_test_main.cpp")
     
---     add_includedirs("src/Evaluator")
---     add_files("src/Evaluator/Value/value.cpp")
---     add_files("src/VirtualMachine/main.cpp")
---     add_files("src/Core/warning.cpp")
---     add_files("src/Lexer/lexer.cpp")
---     add_files("src/Parser/parser.cpp")
+    set_warnings("all")
 
---     add_includedirs("src")
---     set_warnings("all")
+target("ir_test_main")
+    set_kind("binary")
 
---     add_defines("__FCORE_COMPILE_TIME=\"" .. os.date("%Y-%m-%d %H:%M:%S") .. "\"")
+    add_files("src/IR/ir_test_main.cpp")
+    
+    set_warnings("all")