阶段性保存，全面修改Value为Object

include/Value/function.hpp

@@ -1,32 +1,35 @@
 #pragma once
 
-#include <Value/BaseValue.hpp>
 #include <Ast/functionParameters.hpp>
 #include <context_forward.hpp>
 
 #include <atomic>
+#include <functional>
+#include <memory>
+#include <vector>
 
 namespace Fig
 {
-    class Value;
-
-    /* complex objects */
-    struct FunctionStruct
+    class Object;
+    class Function
     {
+    public:
         std::size_t id;
         Ast::FunctionParameters paras;
         TypeInfo retType;
         Ast::BlockStatement body;
 
         bool isBuiltin = false;
-        std::function<Value(const std::vector<Value> &)> builtin;
+        std::function<Object(const std::vector<Object> &)> builtin;
         int builtinParamCount = -1;
 
         std::shared_ptr<Context> closureContext;
 
-        FunctionStruct() = default;
+        // ===== Constructors =====
+        Function() :
+            id(nextId()) {}
 
-        FunctionStruct(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)),
@@ -35,27 +38,23 @@ namespace Fig
         {
         }
 
-        FunctionStruct(std::function<Value(const std::vector<Value> &)> fn, int argc);
+        Function(std::function<Object(const std::vector<Object> &)> fn, int argc) :
+            id(nextId()), isBuiltin(true), builtin(std::move(fn)), builtinParamCount(argc)
+        {
+        }
 
-        FunctionStruct(const FunctionStruct &other) :
-            id(other.id),
-            paras(other.paras),
-            retType(other.retType),
-            body(other.body),
-            isBuiltin(other.isBuiltin),
-            builtin(other.builtin),
-            builtinParamCount(other.builtinParamCount),
-            closureContext(other.closureContext) {}
+        // ===== Copy / Move =====
+        Function(const Function &other) = default;
+        Function(Function &&) noexcept = default;
+        Function &operator=(const Function &) = default;
+        Function &operator=(Function &&) noexcept = default;
 
-        FunctionStruct &operator=(const FunctionStruct &other) = default;
-        FunctionStruct(FunctionStruct &&) noexcept = default;
-        FunctionStruct &operator=(FunctionStruct &&) noexcept = default;
-
-        bool operator==(const FunctionStruct &other) const noexcept
+        // ===== Comparison =====
+        bool operator==(const Function &other) const noexcept
         {
             return id == other.id;
         }
-        bool operator!=(const FunctionStruct &other) const noexcept
+        bool operator!=(const Function &other) const noexcept
         {
             return !(*this == other);
         }
@@ -67,31 +66,4 @@ namespace Fig
             return counter++;
         }
     };
-
-    class Function final : public __ValueWrapper<FunctionStruct>
-    {
-    public:
-        Function(const FunctionStruct &x) :
-            __ValueWrapper(ValueType::Function)
-        {
-            data = std::make_unique<FunctionStruct>(x);
-        }
-        Function(Ast::FunctionParameters paras, TypeInfo ret, Ast::BlockStatement body, ContextPtr closureContext) :
-            __ValueWrapper(ValueType::Function)
-        {
-            data = std::make_unique<FunctionStruct>(
-                std::move(paras), std::move(ret), std::move(body), std::move(closureContext));
-        }
-        Function(std::function<Value(const std::vector<Value> &)> fn, int argc);
-
-        bool operator==(const Function &other) const noexcept
-        {
-            if (!data || !other.data) return false;
-            return *data == *other.data; // call -> FunctionStruct::operator== (based on ID comparing)
-        }
-        Function(const Function &) = default;
-        Function(Function &&) noexcept = default;
-        Function &operator=(const Function &) = default;
-        Function &operator=(Function &&) noexcept = default;
-    };
 } // namespace Fig