回档之后的重写。部分问题修复。添加了什么我也忘了

src/Evaluator/Context/context.hpp

@@ -1,17 +1,19 @@
 #pragma once
 
-#include "Ast/Statements/InterfaceDefSt.hpp"
-#include "Value/interface.hpp"
-#include <Value/Type.hpp>
+#include "Evaluator/Value/function.hpp"
+#include <Ast/Statements/InterfaceDefSt.hpp>
+#include <Evaluator/Value/interface.hpp>
+#include <Evaluator/Value/Type.hpp>
 #include <algorithm>
+#include <cstddef>
 #include <unordered_map>
 #include <iostream>
 #include <memory>
 
-#include <Context/context_forward.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>
 
 namespace Fig
 {
@@ -30,8 +32,8 @@ namespace Fig
         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;
@@ -51,14 +53,24 @@ 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());
             // 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)
         {
@@ -122,12 +134,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>();
@@ -142,34 +148,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)
         // {
@@ -233,6 +225,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);

src/Evaluator/Core/Eval.cpp

@@ -0,0 +1,124 @@
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    RvObject 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 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 evalLv(exp, ctx).get();
+
+            case AstType::FunctionCall: {
+                auto fnCall = std::static_pointer_cast<Ast::FunctionCallExpr>(exp);
+               
+                Ast::Expression callee = fnCall->callee;
+                ObjectPtr fnObj = eval(callee, ctx);
+                if (fnObj->getTypeInfo() != ValueType::Function)
+                {
+                    throw EvaluatorError(u8"ObjectNotCallable",
+                                         std::format("Object `{}` isn't callable", fnObj->toString().toBasicString()),
+                                         callee);
+                }
+                const Function &fn = fnObj->as<Function>();
+                size_t fnId = fn.id;
+                // const auto &fnNameOpt = ctx->getFunctionName(fnId);
+                // const FString &fnName = (fnNameOpt ? *fnNameOpt :
+                // u8"<anonymous>");
+
+                auto fnNameOpt = ctx->getFunctionName(fnId);
+                if (!fnNameOpt && fn.closureContext) fnNameOpt = fn.closureContext->getFunctionName(fnId);
+
+                const FString &fnName = (fnNameOpt ? *fnNameOpt : u8"<anonymous> or builtin-type member function");
+
+                return evalFunctionCall(fn, fnCall->arg, fnName, 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(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(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[eval(key, ctx)] = 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,287 @@
+#include <Evaluator/Value/value.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/Value/IntPool.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    RvObject Evaluator::evalBinary(Ast::BinaryExpr bin, ContextPtr ctx)
+    {
+        using Ast::Operator;
+        Operator op = bin->op;
+        Ast::Expression lexp = bin->lexp, rexp = bin->rexp;
+        switch (op)
+        {
+            case Operator::Add: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs / *rhs);
+            };
+            case Operator::Modulo: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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(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::Power: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                if (lhs->is<ValueType::IntClass>() && rhs->is<ValueType::IntClass>())
+                {
+                    ValueType::IntClass result =
+                        std::pow(lhs->as<ValueType::IntClass>(), rhs->as<ValueType::IntClass>());
+                    return IntPool::getInstance().createInt(result);
+                }
+                return std::make_shared<Object>(power(*lhs, *rhs));
+            }
+            case Operator::And: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                if (lhs->is<bool>() && !isBoolObjectTruthy(lhs))
+                {
+                    return Object::getFalseInstance(); // short-circuit
+                }
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs && *rhs);
+            };
+            case Operator::Or: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                if (lhs->is<bool>() && isBoolObjectTruthy(lhs))
+                {
+                    return Object::getTrueInstance();
+                }
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs || *rhs);
+            };
+            case Operator::Equal: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs == *rhs);
+            }
+            case Operator::NotEqual: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs != *rhs);
+            }
+            case Operator::Less: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs < *rhs);
+            }
+            case Operator::LessEqual: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs <= *rhs);
+            }
+            case Operator::Greater: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs > *rhs);
+            }
+            case Operator::GreaterEqual: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                return std::make_shared<Object>(*lhs >= *rhs);
+            }
+            case Operator::Is: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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::BitAnd: {
+                ObjectPtr lhs = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = eval(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+
+                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 = evalLv(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                lv.set(rhs);
+                return rhs;
+            }
+            case Operator::PlusAssign: {
+                LvObject lv = evalLv(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                lv.set(std::make_shared<Object>(*(lv.get()) + *rhs));
+                return rhs;
+            }
+            case Operator::MinusAssign: {
+                LvObject lv = evalLv(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                lv.set(std::make_shared<Object>(*(lv.get()) - *rhs));
+                return rhs;
+            }
+            case Operator::AsteriskAssign: {
+                LvObject lv = evalLv(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                lv.set(std::make_shared<Object>(*(lv.get()) * (*rhs)));
+                return rhs;
+            }
+            case Operator::SlashAssign: {
+                LvObject lv = evalLv(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                lv.set(std::make_shared<Object>(*(lv.get()) / *rhs));
+                return rhs;
+            }
+            case Operator::PercentAssign: {
+                LvObject lv = evalLv(lexp, ctx);
+                ObjectPtr rhs = eval(rexp, ctx);
+                lv.set(std::make_shared<Object>(*(lv.get()) / *rhs));
+                return rhs;
+            }
+            // case Operator::CaretAssign: {
+            //     LvObject lv = evalLv(lexp, ctx);
+            //     ObjectPtr rhs = eval(rexp, ctx);
+            //     lv.set(std::make_shared<Object>(
+            //         *(lv.get()) ^ *rhs));
+            // }
+            default:
+                throw EvaluatorError(u8"UnsupportedOp",
+                                     std::format("Unsupport operator '{}' for binary", magic_enum::enum_name(op)),
+                                     bin);
+        }
+    }
+};

src/Evaluator/Core/EvalFunctionCall.cpp

@@ -0,0 +1,183 @@
+#include <Evaluator/Value/function.hpp>
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    RvObject Evaluator::evalFunctionCall(const Function &fn,
+                                         const Ast::FunctionArguments &fnArgs,
+                                         const FString &fnName,
+                                         ContextPtr ctx)
+    {
+        const Function &fnStruct = fn;
+        Ast::FunctionCallArgs evaluatedArgs;
+        if (fnStruct.type == Function::Builtin || fnStruct.type == Function::MemberType)
+        {
+            for (const auto &argExpr : fnArgs.argv) { evaluatedArgs.argv.push_back(eval(argExpr, ctx)); }
+            if (fnStruct.builtinParamCount != -1 && fnStruct.builtinParamCount != evaluatedArgs.getLength())
+            {
+                throw EvaluatorError(u8"BuiltinArgumentMismatchError",
+                                     std::format("Builtin function '{}' expects {} arguments, but {} were provided",
+                                                 fnName.toBasicString(),
+                                                 fnStruct.builtinParamCount,
+                                                 evaluatedArgs.getLength()),
+                                     fnArgs.argv.back());
+            }
+            if (fnStruct.type == Function::Builtin) 
+            {
+                return fnStruct.builtin(evaluatedArgs.argv);
+            }
+            else
+            {
+                return fnStruct.mtFn(nullptr, evaluatedArgs.argv); // wrapped member type function (`this` provided by evalMemberExpr)
+            }
+        }
+
+        // check argument, all types of parameters
+        Ast::FunctionParameters fnParas = fnStruct.paras;
+
+        // create new context for function call
+        auto newContext = std::make_shared<Context>(FString(std::format("<Function {}()>", fnName.toBasicString())),
+                                                    fnStruct.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++)
+        {
+            TypeInfo expectedType(fnParas.posParas[i].second); // look up type info, if exists a type with the
+                                                               // name, use it, else throw
+            ObjectPtr argVal = eval(fnArgs.argv[i], ctx);
+            TypeInfo actualType = argVal->getTypeInfo();
+            if (!isTypeMatch(expectedType, argVal, ctx))
+            {
+                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();
+            TypeInfo expectedType(fnParas.defParas[defParamIndex].second.first);
+
+            ObjectPtr defaultVal = eval(fnParas.defParas[defParamIndex].second.second, ctx);
+            if (!isTypeMatch(expectedType, defaultVal, ctx))
+            {
+                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 = eval(fnArgs.argv[i], ctx);
+            TypeInfo actualType = argVal->getTypeInfo();
+            if (!isTypeMatch(expectedType, argVal, ctx))
+            {
+                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 = eval(fnParas.defParas[defParamIndex].second.second, ctx);
+            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 = TypeInfo(fnParas.posParas[j].second);
+            }
+            else
+            {
+                size_t defParamIndex = j - fnParas.posParas.size();
+                paramName = fnParas.defParas[defParamIndex].first;
+                paramType = TypeInfo(fnParas.defParas[defParamIndex].second.first);
+            }
+            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(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 = Object::getNullInstance();
+        for (const auto &stmt : fnStruct.body->stmts)
+        {
+            StatementResult sr = evalStatement(stmt, newContext);
+            if (sr.isError())
+            {
+                throw EvaluatorError(u8"UncaughtExceptionError",
+                                     std::format("Uncaught exception: {}", sr.result->toString().toBasicString()),
+                                     stmt);
+            }
+            if (!sr.isNormal())
+            {
+                retVal = sr.result;
+                break;
+            }
+        }
+        if (!isTypeMatch(fnStruct.retType, retVal, ctx))
+        {
+            throw EvaluatorError(u8"ReturnTypeMismatchError",
+                                 std::format("Function '{}' expects return type '{}', but got type '{}'",
+                                             fnName.toBasicString(),
+                                             fnStruct.retType.toString().toBasicString(),
+                                             prettyType(retVal).toBasicString()),
+                                 fnStruct.body);
+        }
+        return retVal;
+    }
+    }
+}; // namespace Fig

src/Evaluator/Core/EvalInitExpr.cpp

@@ -0,0 +1,364 @@
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    RvObject Evaluator::evalInitExpr(Ast::InitExpr initExpr, ContextPtr ctx)
+    {
+        LvObject structeLv = 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 = 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, eval(argExpr, ctx)});
+            }
+        };
+
+        ContextPtr instanceCtx =
+            std::make_shared<Context>(FString(std::format("<StructInstance {}>", structName.toBasicString())), ctx);
+        /*
+            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 = 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 = 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 = 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 = 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())
+        {
+            auto funcNameOpt = stDefCtx->getFunctionName(id);
+            assert(funcNameOpt.has_value());
+
+            const FString &funcName = *funcNameOpt;
+            auto funcSlot = stDefCtx->get(funcName);
+
+            instanceCtx->def(funcName,
+                             ValueType::Function,
+                             funcSlot->am,
+                             std::make_shared<Object>(Function(fn.paras, fn.retType, fn.body, instanceCtx)));
+        }
+
+        return std::make_shared<Object>(StructInstance(structT.type, instanceCtx));
+    }
+};

src/Evaluator/Core/EvalLvObject.cpp

@@ -0,0 +1,195 @@
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    LvObject Evaluator::evalVarExpr(Ast::VarExpr var, ContextPtr ctx)
+    {
+        const FString &name = var->name;
+        if (!ctx->contains(name)) { throw EvaluatorError(u8"UndeclaredIdentifierError", name, var); }
+        return LvObject(ctx->get(name), ctx);
+    }
+    LvObject Evaluator::evalMemberExpr(Ast::MemberExpr me, ContextPtr ctx)
+    {
+        // LvObject base = evalLv(me->base, ctx);
+        RvObject baseVal = eval(me->base, ctx);
+        const FString &member = me->member;
+        if (baseVal->getTypeInfo() == ValueType::Module)
+        {
+            const Module &mod = baseVal->as<Module>();
+            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(
+                                    [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(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(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(ifm.paras, actualType(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);
+        }
+    }
+    LvObject Evaluator::evalIndexExpr(Ast::IndexExpr ie, ContextPtr ctx)
+    {
+        RvObject base = eval(ie->base, ctx);
+        RvObject index = 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);
+        }
+    }
+    LvObject 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,510 @@
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+#include <Utils/utils.hpp>
+
+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 = 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 = 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 = eval(fnDef->retType, ctx);
+                    returnType = actualType(returnTypeValue);
+                }
+
+                Function fn(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);
+                }
+                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 = eval(field.declaredType, ctx);
+                        fieldType = actualType(declaredTypeValue);
+                    }
+
+                    fields.push_back(Field(field.am, field.fieldName, fieldType, field.defaultValueExpr));
+                }
+                ContextPtr defContext = std::make_shared<Context>(FString(std::format("<Struct {} at {}:{}>",
+                                                                                      stDef->name.toBasicString(),
+                                                                                      stDef->getAAI().line,
+                                                                                      stDef->getAAI().column)),
+                                                                  ctx);
+                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
+                }
+
+                AccessModifier am = (stDef->isPublic ? AccessModifier::PublicConst : AccessModifier::Const);
+                TypeInfo type(stDef->name, true); // register type name
+                ctx->def(stDef->name,
+                         ValueType::StructType,
+                         am,
+                         std::make_shared<Object>(StructType(type, defContext, fields)));
+                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;
+                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 = eval(ifMethod.returnType, ctx);
+
+                    record.implMethods[name] =
+                        Function(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 = 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 = 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 = 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 = 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();
+                for (auto &stmt : tryst->body->stmts)
+                {
+                    sr = evalStatement(stmt, tryCtx); // eval in try context
+                    if (sr.isError()) { 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)
+                {
+                    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 = 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 = 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 StatementResult::normal(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()))));
+        }
+    }
+};

src/Evaluator/Core/EvalTernary.cpp

@@ -0,0 +1,20 @@
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+
+    RvObject Evaluator::evalTernary(Ast::TernaryExpr te, ContextPtr ctx)
+    {
+        RvObject condVal = 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,31 @@
+#include <Evaluator/Value/LvObject.hpp>
+#include <Evaluator/evaluator.hpp>
+#include <Evaluator/evaluator_error.hpp>
+
+namespace Fig
+{
+    RvObject Evaluator::evalUnary(Ast::UnaryExpr un, ContextPtr ctx)
+    {
+        using Ast::Operator;
+        Operator op = un->op;
+        Ast::Expression exp = un->exp;
+        ObjectPtr value = eval(exp, ctx);
+        switch (op)
+        {
+            case Operator::Not: {
+                return std::make_shared<Object>(!(*value));
+            }
+            case Operator::Subtract: {
+                return std::make_shared<Object>(-(*value));
+            }
+            case Operator::BitNot: {
+                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);
+            }
+        }
+    }
+};

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

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "Value/value.hpp"
+#include <Evaluator/Value/value.hpp>
 #include <Core/fig_string.hpp>
-#include <Value/value_forward.hpp>
-#include <Value/Type.hpp>
+#include <Evaluator/Value/value_forward.hpp>
+#include <Evaluator/Value/Type.hpp>
 #include <array>
 #include <memory>
 
@@ -30,6 +30,11 @@ namespace Fig
             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()
         {

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
 {

src/Evaluator/Value/Type.hpp

@@ -14,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;
@@ -77,39 +65,31 @@ namespace Fig
         using NullClass = std::monostate;
         using StringClass = FString;
 
-        static const std::unordered_set<TypeInfo, TypeInfoHash> builtinTypes
-        {
-            Any,
-            Null,
-            Int,
-            String,
-            Bool,
-            Double,
-            Function,
-            StructType,
-            StructInstance,
-            List,
-            Map,
-            Module,
-            InterfaceType
-        };
-
         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,8 +3,8 @@
 
 #include <Ast/AccessModifier.hpp>
 #include <Core/fig_string.hpp>
-#include <Value/Type.hpp>
-#include <Value/value_forward.hpp>
+#include <Evaluator/Value/Type.hpp>
+#include <Evaluator/Value/value_forward.hpp>
 
 #include <memory>
 namespace Fig

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,97 @@
 namespace Fig
 {
     class Object;
+
     class Function
     {
     public:
         std::size_t id;
-        Ast::FunctionParameters paras;
-        TypeInfo retType;
-        Ast::BlockStatement body;
 
-        bool isBuiltin = false;
-        std::function<std::shared_ptr<Object>(const std::vector<std::shared_ptr<Object>> &)> builtin;
+        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;
+        };
+
         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(Ast::FunctionParameters _paras,
+                 TypeInfo _retType,
+                 Ast::BlockStatement _body,
+                 ContextPtr _closureContext) :
             id(nextId()), // 分配唯一 ID
             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) {}
+            id(nextId()), type(Builtin), builtin(fn), builtinParamCount(argc)
+        {
+            type = Builtin;
+        }
+
+        Function(std::function<std::shared_ptr<Object>(std::shared_ptr<Object>,
+                                                       const std::vector<std::shared_ptr<Object>> &)> fn,
+                 int argc) :
+            id(nextId()), 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 +109,43 @@ 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)
+        {
+            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,13 +1,13 @@
-#include "Value/structType.hpp"
-#include <Value/Type.hpp>
-#include <Value/value.hpp>
-#include <Context/context.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"))
@@ -20,17 +20,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())));
                 // *this = ValueType::String;
             }
-            id = typeMap.at(name); // may throw
+            id = getTypeMap().at(name); // may throw
         }
     }
 

src/Evaluator/Value/value.hpp

@@ -1,13 +1,16 @@
 #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 <Value/value_forward.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 <variant>
 #include <cmath>
@@ -41,26 +44,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); }
     };
@@ -74,231 +69,237 @@ 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;
@@ -359,49 +360,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>(); }
@@ -427,13 +429,12 @@ namespace Fig
         {
             if (is<ValueType::NullClass>()) return FString(u8"null");
             if (is<ValueType::IntClass>()) return FString(std::to_string(as<ValueType::IntClass>()));
-            if (is<ValueType::DoubleClass>()) return FString(std::format("{}", as<ValueType::DoubleClass>()));
+            if (is<ValueType::DoubleClass>()) return FString(std::format("{:g}", as<ValueType::DoubleClass>()));
             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(),
@@ -449,8 +450,7 @@ namespace Fig
                 bool first_flag = true;
                 for (auto &ele : list)
                 {
-                    if (!first_flag)
-                        output += u8", ";
+                    if (!first_flag) output += u8", ";
                     output += ele.value->toString();
                     first_flag = false;
                 }
@@ -464,8 +464,7 @@ namespace Fig
                 bool first_flag = true;
                 for (auto &[key, value] : map)
                 {
-                    if (!first_flag)
-                        output += u8", ";
+                    if (!first_flag) output += u8", ";
                     output += key.value->toString() + FString(u8" : ") + value->toString();
                     first_flag = false;
                 }
@@ -474,24 +473,22 @@ 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>");
         }
 
     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();
@@ -508,8 +505,7 @@ namespace Fig
             {
                 bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
                 auto result = lhs.getNumericValue() + rhs.getNumericValue();
-                if (bothInt)
-                    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>())
@@ -525,8 +521,7 @@ namespace Fig
             {
                 bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
                 auto result = lhs.getNumericValue() - rhs.getNumericValue();
-                if (bothInt)
-                    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)));
@@ -540,18 +535,14 @@ namespace Fig
             {
                 bool bothInt = lhs.is<ValueType::IntClass>() && rhs.is<ValueType::IntClass>();
                 auto result = lhs.getNumericValue() * rhs.getNumericValue();
-                if (bothInt)
-                    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;
-                }
+                for (size_t i = 0; i < rhs.getNumericValue(); ++i) { result += l; }
                 return Object(result);
             }
             throw ValueError(FString(makeTypeErrorMessage("Unsupported operation", "*", lhs, rhs)));
@@ -564,8 +555,7 @@ 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)
@@ -593,12 +583,11 @@ namespace Fig
                 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)));
+                if (rnv == 0) throw ValueError(FString(makeTypeErrorMessage("Modulo by zero", "/", lhs, rhs)));
                 auto result = std::fmod(lhs.getNumericValue(), rnv);
                 return Object(result);
             }
@@ -623,25 +612,25 @@ 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>());
         }
 
@@ -690,7 +679,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>());
         }
 
@@ -716,14 +706,19 @@ namespace Fig
             {
                 bool bothInt = base.is<ValueType::IntClass>() && exp.is<ValueType::IntClass>();
                 auto result = std::pow(base.getNumericValue(), exp.getNumericValue());
-                if (bothInt)
-                    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)));
         }
     };
 
+    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/evaluator.hpp

@@ -1,62 +1,20 @@
-#include "Ast/Expressions/InitExpr.hpp"
+#pragma once
+#include <Ast/Expressions/InitExpr.hpp>
 #include <Ast/Statements/ImplementSt.hpp>
 #include <Ast/Statements/InterfaceDefSt.hpp>
-#include <Value/Type.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 <filesystem>
 
+#include <Evaluator/Core/StatementResult.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; }
-    };
-
     class Evaluator
     {
     private:
@@ -92,7 +50,7 @@ namespace Fig
         {
             assert(global != nullptr);
 
-            for (auto &[name, fn] : Builtins::builtinFunctions)
+            for (auto &[name, fn] : Builtins::getBuiltinFunctions())
             {
                 int argc = Builtins::getBuiltinFunctionParamCount(name);
                 Function f(fn, argc);
@@ -108,7 +66,7 @@ namespace Fig
         {
             assert(global != nullptr);
 
-            for (auto &[name, val] : Builtins::builtinValues)
+            for (auto &[name, val] : Builtins::getBuiltinValues())
             {
                 global->def(
                     name,

src/Evaluator/main.cpp

@@ -1,195 +0,0 @@
-/*
- ███████████ █████   █████ ██████████    ███████████ █████   █████████     █████         █████████   ██████   █████   █████████  █████  █████   █████████     █████████  ██████████
-░█░░░███░░░█░░███   ░░███ ░░███░░░░░█   ░░███░░░░░░█░░███   ███░░░░░███   ░░███         ███░░░░░███ ░░██████ ░░███   ███░░░░░███░░███  ░░███   ███░░░░░███   ███░░░░░███░░███░░░░░█
-░   ░███  ░  ░███    ░███  ░███  █ ░     ░███   █ ░  ░███  ███     ░░░     ░███        ░███    ░███  ░███░███ ░███  ███     ░░░  ░███   ░███  ░███    ░███  ███     ░░░  ░███  █ ░
-    ░███     ░███████████  ░██████       ░███████    ░███ ░███             ░███        ░███████████  ░███░░███░███ ░███          ░███   ░███  ░███████████ ░███          ░██████
-    ░███     ░███░░░░░███  ░███░░█       ░███░░░█    ░███ ░███    █████    ░███        ░███░░░░░███  ░███ ░░██████ ░███    █████ ░███   ░███  ░███░░░░░███ ░███    █████ ░███░░█
-    ░███     ░███    ░███  ░███ ░   █    ░███  ░     ░███ ░░███  ░░███     ░███      █ ░███    ░███  ░███  ░░█████ ░░███  ░░███  ░███   ░███  ░███    ░███ ░░███  ░░███  ░███ ░   █
-    █████    █████   █████ ██████████    █████       █████ ░░█████████     ███████████ █████   █████ █████  ░░█████ ░░█████████  ░░████████   █████   █████ ░░█████████  ██████████
-   ░░░░░    ░░░░░   ░░░░░ ░░░░░░░░░░    ░░░░░       ░░░░░   ░░░░░░░░░     ░░░░░░░░░░░ ░░░░░   ░░░░░ ░░░░░    ░░░░░   ░░░░░░░░░    ░░░░░░░░   ░░░░░   ░░░░░   ░░░░░░░░░  ░░░░░░░░░░
-
-
-                                                                                    .---.
-           .              __.....__                         .--.                    |   |             _..._                                               __.....__
-         .'|          .-''         '.                  _.._ |__|  .--./)            |   |           .'     '.   .--./)                        .--./)  .-''         '.
-     .| <  |         /     .-''"'-.  `.              .' .._|.--. /.''\\             |   |          .   .-.   . /.''\\                        /.''\\  /     .-''"'-.  `.
-   .' |_ | |        /     /________\   \             | '    |  || |  | |            |   |    __    |  '   '  || |  | |                 __   | |  | |/     /________\   \
- .'     || | .'''-. |                  |           __| |__  |  | \`-' /             |   | .:--.'.  |  |   |  | \`-' /      _    _   .:--.'.  \`-' / |                  |
-'--.  .-'| |/.'''. \\    .-------------'          |__   __| |  | /("'`              |   |/ |   \ | |  |   |  | /("'`      | '  / | / |   \ | /("'`  \    .-------------'
-   |  |  |  /    | | \    '-.____...---.             | |    |  | \ '---.            |   |`" __ | | |  |   |  | \ '---.   .' | .' | `" __ | | \ '---. \    '-.____...---.
-   |  |  | |     | |  `.             .'              | |    |__|  /'""'.\           |   | .'.''| | |  |   |  |  /'""'.\  /  | /  |  .'.''| |  /'""'.\ `.             .'
-   |  '.'| |     | |    `''-...... -'                | |         ||     ||          '---'/ /   | |_|  |   |  | ||     |||   `'.  | / /   | |_||     ||  `''-...... -'
-   |   / | '.    | '.                                | |         \'. __//                \ \._,\ '/|  |   |  | \'. __// '   .'|  '/\ \._,\ '/\'. __//
-   `'-'  '---'   '---'                               |_|          `'---'                  `--'  `" '--'   '--'  `'---'   `-'  `--'  `--'  `"  `'---'
-
-Copyright (C) 2020-2026 PuqiAR
-
-This software is licensed under the MIT License. See LICENSE.txt for details.
-*/
-
-#include <Utils/argparse/argparse.hpp>
-// #include <print>
-#include <fstream>
-
-#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>
-
-static size_t addressableErrorCount = 0;
-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("-v", "--version")
-    //     .help("get the version of Fig Interpreter")
-    //     .default_value(false)
-    //     .implicit_value(true);
-    // interpreter
-
-    try
-    {
-        program.parse_args(argc, argv);
-    }
-    catch (const std::exception &e)
-    {
-        std::cerr << e.what() << '\n';
-        return 1;
-    }
-    // if (program.get<bool>("--version"))
-    // {
-    //     std::print("Fig Interpreter version {}\n", Fig::Core::VERSION);
-    //     return 0;
-    // }
-    Fig::FString sourcePath(program.get<std::string>("source"));
-    if (sourcePath.empty())
-    {
-        std::cerr << "No source file provided.\n";
-        return 1;
-    }
-    std::ifstream file(sourcePath.toBasicString());
-    if (!file.is_open())
-    {
-        std::cerr << "Could not open file: " << sourcePath.toBasicString() << '\n';
-        return 1;
-    }
-    std::string source((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-    file.close();
-
-    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)
-    // {
-    //     std::println("{}", tok.toString().toBasicString());
-    // }
-
-    Fig::Parser parser(lexer, sourcePath, sourceLines);
-    std::vector<Fig::Ast::AstBase> asts;
-
-    try
-    {
-        asts = parser.parseAll();
-    }
-    catch (const Fig::AddressableError &e)
-    {
-        addressableErrorCount++;
-        ErrorLog::logAddressableError(e);
-        return 1;
-    }
-    catch (const Fig::UnaddressableError &e)
-    {
-        unaddressableErrorCount++;
-        ErrorLog::logUnaddressableError(e);
-        return 1;
-    }
-    catch (const std::exception &e)
-    {
-        std::cerr << "uncaught exception of: " << e.what() << '\n';
-        return 1;
-    }
-
-    // AstPrinter printer;
-    // std::print("<Debug> AST:\n");
-    // for (const auto &node : ast)
-    // {
-    //     printer.print(node);
-    // }
-
-    Fig::Evaluator evaluator;
-
-    evaluator.SetSourcePath(sourcePath);
-    evaluator.SetSourceLines(sourceLines);
-    evaluator.CreateGlobalContext();
-    evaluator.RegisterBuiltinsValue(); 
-
-    try
-    {
-        evaluator.Run(asts);
-    }
-    catch (const Fig::AddressableError &e)
-    {
-        addressableErrorCount++;
-        ErrorLog::logAddressableError(e);
-        evaluator.printStackTrace();
-        return 1;
-    }
-    catch (const Fig::UnaddressableError &e)
-    {
-        unaddressableErrorCount++;
-        ErrorLog::logUnaddressableError(e);
-        evaluator.printStackTrace();
-        return 1;
-    }
-    catch (const std::exception &e)
-    {
-        std::cerr << "uncaught exception of: " << e.what() << '\n';
-        evaluator.printStackTrace();
-        return 1;
-    }
-
-    // try
-    // {
-    //     std::vector<Fig::Ast> ast = parser.parseAll();
-    //     AstPrinter printer;
-
-    //     std::print("<Debug> AST:\n");
-    //     for (const auto &node : ast)
-    //     {
-    //         printer.print(node);
-    //     }
-
-    //     Fig::Evaluator evaluator(ast);
-    //     evaluator.run();
-    // }
-    // catch (const Fig::AddressableError &e)
-    // {
-    //     std::cerr << e.what() << '\n';
-    //     return 1;
-    // }
-    // catch (const Fig::UnaddressableError &e)
-    // {
-    //     std::cerr << e.what() << '\n';
-    //     return 1;
-    // }
-    // catch (const std::exception &e)
-    // {
-    //     std::cerr << e.what() << '\n';
-    //     return 1;
-    // }
-}