@ugo-studio/jspp 0.1.1 → 0.1.3

package/src/prelude/any_value_helpers.hpp

@@ -0,0 +1,225 @@
+#pragma once
+
+#include "types.hpp"
+#include "any_value.hpp"
+#include "values/string.hpp"
+
+const bool jspp::AnyValue::is_truthy() const noexcept
+{
+    switch (storage.type)
+    {
+    case JsType::Boolean:
+        return storage.boolean;
+    case JsType::Number:
+        return storage.number != 0.0;
+    case JsType::String:
+        return !storage.str->value.empty();
+    case JsType::Undefined:
+        return false;
+    case JsType::Null:
+        return false;
+    case JsType::Uninitialized:
+        return false;
+    default:
+        return true;
+    }
+}
+
+const bool jspp::AnyValue::is_strictly_equal_to(const AnyValue &other) const noexcept
+{
+    if (storage.type == other.storage.type)
+    {
+        switch (storage.type)
+        {
+        case JsType::Boolean:
+            return storage.boolean == other.storage.boolean;
+        case JsType::Number:
+            return storage.number == other.storage.number;
+        case JsType::String:
+            return (storage.str->value == other.storage.str->value);
+        case JsType::Array:
+            return (storage.array == other.storage.array);
+        case JsType::Object:
+            return (storage.object == other.storage.object);
+        case JsType::Function:
+            return (storage.function == other.storage.function);
+        case JsType::Symbol:
+            // Symbols are unique by reference/pointer identity
+            return (storage.symbol == other.storage.symbol);
+        case JsType::DataDescriptor:
+            return (resolve_property_for_read(*this).is_strictly_equal_to(resolve_property_for_read(other)));
+        case JsType::AccessorDescriptor:
+            return (resolve_property_for_read(*this).is_strictly_equal_to(resolve_property_for_read(other)));
+        default:
+            return true;
+        }
+    }
+    return false;
+}
+const bool jspp::AnyValue::is_equal_to(const AnyValue &other) const noexcept
+{
+    // Implements JavaScript's Abstract Equality Comparison Algorithm (==)
+    // Step 1: If types are the same, use strict equality (===)
+    if (storage.type == other.storage.type)
+    {
+        return is_strictly_equal_to(other);
+    }
+    // Steps 2 & 3: null == undefined
+    if ((is_null() && other.is_undefined()) || (is_undefined() && other.is_null()))
+    {
+        return true;
+    }
+    // Step 4 & 5: number == string
+    if (is_number() && other.is_string())
+    {
+        double num_this = this->as_double();
+        double num_other;
+        try
+        {
+            const std::string &s = other.as_string()->value;
+            // JS considers empty string or whitespace-only string to be 0
+            if (s.empty() || std::all_of(s.begin(), s.end(), [](unsigned char c)
+                                         { return std::isspace(c); }))
+            {
+                num_other = 0.0;
+            }
+            else
+            {
+                size_t pos;
+                num_other = std::stod(s, &pos);
+                // Check if the entire string was consumed, allowing for trailing whitespace
+                while (pos < s.length() && std::isspace(static_cast<unsigned char>(s[pos])))
+                {
+                    pos++;
+                }
+                if (pos != s.length())
+                {
+                    num_other = std::numeric_limits<double>::quiet_NaN();
+                }
+            }
+        }
+        catch (...)
+        {
+            num_other = std::numeric_limits<double>::quiet_NaN();
+        }
+        return num_this == num_other;
+    }
+    if (is_string() && other.is_number())
+    {
+        // Delegate to the other operand to avoid code duplication
+        return other.is_equal_to(*this);
+    }
+    // Step 6 & 7: boolean == any
+    if (is_boolean())
+    {
+        // Convert boolean to number and re-compare
+        return AnyValue::make_number(as_boolean() ? 1.0 : 0.0).is_equal_to(other);
+    }
+    if (other.is_boolean())
+    {
+        // Convert boolean to number and re-compare
+        return is_equal_to(AnyValue::make_number(other.as_boolean() ? 1.0 : 0.0));
+    }
+    // Step 8 & 9: object == (string or number or symbol)
+    // Simplified: Objects convert to primitives.
+    if ((is_object() || is_array() || is_function()) && (other.is_string() || other.is_number() || other.is_symbol()))
+    {
+        // Convert object to primitive (string) and re-compare.
+        // This is a simplification of JS's ToPrimitive.
+        return AnyValue::make_string(to_std_string()).is_equal_to(other);
+    }
+    if ((other.is_object() || other.is_array() || other.is_function()) && (is_string() || is_number() || is_symbol()))
+    {
+        return other.is_equal_to(*this);
+    }
+    // Step 10: Parse datacriptor or accessor descriptor to primitive and re-compare
+    if (is_data_descriptor() || is_accessor_descriptor())
+    {
+        AnyValue prim = resolve_property_for_read(*this);
+        return prim.is_equal_to(other);
+    }
+    // Step 11: All other cases (e.g., object == null) are false.
+    return false;
+}
+
+const jspp::AnyValue jspp::AnyValue::is_strictly_equal_to_primitive(const AnyValue &other) const noexcept
+{
+    return AnyValue::make_boolean(is_strictly_equal_to(other));
+}
+const jspp::AnyValue jspp::AnyValue::is_equal_to_primitive(const AnyValue &other) const noexcept
+{
+    return AnyValue::make_boolean(is_equal_to(other));
+}
+
+const jspp::AnyValue jspp::AnyValue::not_strictly_equal_to_primitive(const AnyValue &other) const noexcept
+{
+    return AnyValue::make_boolean(!is_strictly_equal_to(other));
+}
+const jspp::AnyValue jspp::AnyValue::not_equal_to_primitive(const AnyValue &other) const noexcept
+{
+    return AnyValue::make_boolean(!is_equal_to(other));
+}
+
+const std::string jspp::AnyValue::to_std_string() const noexcept
+{
+    switch (storage.type)
+    {
+    case JsType::Undefined:
+        return "undefined";
+    case JsType::Null:
+        return "null";
+    case JsType::Boolean:
+        return storage.boolean ? "true" : "false";
+    case JsType::String:
+        return storage.str->to_std_string();
+    case JsType::Object:
+        return storage.object->to_std_string();
+    case JsType::Array:
+        return storage.array->to_std_string();
+    case JsType::Function:
+        return storage.function->to_std_string();
+    case JsType::Iterator:
+        return storage.iterator->to_std_string();
+    case JsType::Symbol:
+        return storage.symbol->to_std_string();
+    case JsType::DataDescriptor:
+        return storage.data_desc->value->to_std_string();
+    case JsType::AccessorDescriptor:
+    {
+        if (storage.accessor_desc->get.has_value())
+            return storage.accessor_desc->get.value()({}).to_std_string();
+        else
+            return "undefined";
+    }
+    case JsType::Number:
+    {
+        if (std::isnan(storage.number))
+        {
+            return "NaN";
+        }
+        if (std::abs(storage.number) >= 1e21 || (std::abs(storage.number) > 0 && std::abs(storage.number) < 1e-6))
+        {
+            std::ostringstream oss;
+            oss << std::scientific << std::setprecision(4) << storage.number;
+            return oss.str();
+        }
+        else
+        {
+            std::ostringstream oss;
+            oss << std::setprecision(6) << std::fixed << storage.number;
+            std::string s = oss.str();
+            s.erase(s.find_last_not_of('0') + 1, std::string::npos);
+            if (!s.empty() && s.back() == '.')
+            {
+                s.pop_back();
+            }
+            return s;
+        }
+    }
+    // Uninitialized and default should not be reached under normal circumstances
+    case JsType::Uninitialized:
+        return "<uninitialized>";
+    default:
+        return "";
+    }
+}

package/src/prelude/error_helpers.hpp

@@ -12,8 +12,8 @@ const char *jspp::RuntimeError::what() const noexcept
 jspp::RuntimeError jspp::RuntimeError::make_error(const std::string &message, const std::string &name = "Error")
 {
     auto errorObj = std::make_shared<AnyValue>(AnyValue::make_object({{"message", AnyValue::make_string(message)}, {"name", AnyValue::make_string(name)}}));
-    (*errorObj).set_own_property(WellKnownSymbols::toString, AnyValue::make_function([errorObj](const std::vector<AnyValue> &) -> AnyValue
-                                                                                     {
+    (*errorObj).set_own_property(WellKnownSymbols::toString->key, AnyValue::make_function([errorObj](const std::vector<AnyValue> &) -> AnyValue
+                                                                                          {
                                                                                   AnyValue name = (*errorObj).get_own_property("name");
                                                                                   AnyValue message = (*errorObj).get_own_property("message");
                                                                                   std::string str = "";
@@ -25,7 +25,7 @@ jspp::RuntimeError jspp::RuntimeError::make_error(const std::string &message, co
                                                                                   if (message.is_string())
                                                                                       str += message.to_std_string();
                                                                                   return AnyValue::make_string(str); },
-                                                                                     WellKnownSymbols::toString));
+                                                                                          WellKnownSymbols::toString->key));
     return RuntimeError(errorObj);
 }
 jspp::AnyValue jspp::RuntimeError::error_to_value(const std::exception &ex)

package/src/prelude/index.hpp

@@ -4,21 +4,33 @@
 #include "well_known_symbols.hpp"
 
 // values
+#include "values/symbol.hpp"
 #include "values/non_values.hpp"
 #include "values/object.hpp"
 #include "values/array.hpp"
 #include "values/function.hpp"
+#include "values/iterator.hpp"
+#include "values/string.hpp"
+
 #include "error.hpp"
 #include "descriptors.hpp"
 #include "any_value.hpp"
+#include "any_value_helpers.hpp"
 #include "error_helpers.hpp"
+
+#include "values/prototypes/symbol.hpp"
 #include "values/prototypes/string.hpp"
 #include "values/prototypes/object.hpp"
 #include "values/prototypes/array.hpp"
 #include "values/prototypes/function.hpp"
-#include "values/operators/object.hpp"
-#include "values/operators/array.hpp"
-#include "values/operators/function.hpp"
+#include "values/prototypes/iterator.hpp"
+
+#include "values/helpers/symbol.hpp"
+#include "values/helpers/object.hpp"
+#include "values/helpers/array.hpp"
+#include "values/helpers/function.hpp"
+#include "values/helpers/iterator.hpp"
+#include "values/helpers/string.hpp"
 
 // helpers
 #include "operators.hpp"
@@ -26,4 +38,6 @@
 #include "log_string.hpp"
 
 // js standard libraries
+#include "library/symbol.hpp"
 #include "library/console.hpp"
+#include "library/performance.hpp"

package/src/prelude/library/console.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "chrono"
+#include <chrono>
 #include "types.hpp"
 #include "values/non_values.hpp"
 #include "values/object.hpp"
@@ -12,7 +12,7 @@
 #include <sstream>
 #include <iomanip>
 
-static std::unordered_map<std::string, std::chrono::steady_clock::time_point> timers = {};
+static std::map<std::string, std::chrono::steady_clock::time_point> timers = {};
 
 auto logFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
                                            {
@@ -23,7 +23,7 @@ auto logFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>
                                                        std::cout << " ";
                                                }
                                                std::cout << "\n";
-                                               return jspp::AnyValue::make_undefined(); }, "");
+                                               return jspp::AnyValue::make_undefined(); }, "log");
 auto warnFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
                                             {
                                                 std::cerr << "\033[33m";
@@ -34,7 +34,7 @@ auto warnFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>
                                                         std::cout << " ";
                                                 }
                                                 std::cerr << "\033[0m" << "\n"; // reset
-                                                return jspp::AnyValue::make_undefined(); }, "");
+                                                return jspp::AnyValue::make_undefined(); }, "warn");
 auto errorFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
                                              {
                                                  std::cerr << "\033[31m";
@@ -45,13 +45,13 @@ auto errorFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue
                                                          std::cout << " ";
                                                  }
                                                  std::cerr << "\033[0m" << "\n"; // reset
-                                                 return jspp::AnyValue::make_undefined(); }, "");
+                                                 return jspp::AnyValue::make_undefined(); }, "error");
 auto timeFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue> &args)
                                             {
                                                 auto start = std::chrono::steady_clock::now(); // capture immediately
                                                 auto key_str = args.size() > 0 ? args[0].to_std_string() : "default";
                                                 timers[key_str] = start;
-                                                return jspp::AnyValue::make_undefined(); }, "");
+                                                return jspp::AnyValue::make_undefined(); }, "time");
 
 // helper to format duration in ms -> ms/s/m/h with nice precision
 static auto format_duration = [](double ms) -> std::string
@@ -100,7 +100,7 @@ auto timeEndFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyVal
                                                    {
                                                        std::cout << "Timer '" << key_str << "' does not exist." << "\n";
                                                    }
-                                                   return jspp::AnyValue::make_undefined(); }, "");
+                                                   return jspp::AnyValue::make_undefined(); }, "timeEnd");
 
 inline auto console = jspp::AnyValue::make_object({
     {"log", logFn},

package/src/prelude/library/performance.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <chrono>
+#include "types.hpp"
+#include "values/non_values.hpp"
+#include "values/object.hpp"
+#include "values/function.hpp"
+#include "operators.hpp"
+
+inline auto performance = jspp::AnyValue::make_object({
+    {"now",
+     jspp::AnyValue::make_function(
+         // [C++14 Feature] Generalized Lambda Capture
+         // We initialize 'startTime' RIGHT HERE inside the [].
+         // It acts like a private variable stored inside this specific function.
+         [startTime = std::chrono::steady_clock::now()](const std::vector<jspp::AnyValue> &)
+         {
+             // We calculate the diff against the captured startTime
+             std::chrono::duration<double, std::milli> duration =
+                 std::chrono::steady_clock::now() - startTime;
+
+             return jspp::AnyValue::make_number(duration.count());
+         },
+         "now")},
+});

package/src/prelude/library/symbol.hpp

@@ -1,8 +1,65 @@
 #pragma once
 
 #include "types.hpp"
-#include "object.hpp"
 #include "well_known_symbols.hpp"
 
-inline auto Symbol = jspp::Object::make_object({{"iterator", jspp::Object::make_string(jspp::WellKnownSymbols::iterator)},
-                                                {"toString", jspp::Object::make_string(jspp::WellKnownSymbols::toString)}});
+#include "values/object.hpp"
+#include "any_value.hpp"
+
+inline auto Symbol = jspp::AnyValue::make_object({
+    {"iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator)},
+    {"toString", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::toString)},
+});
+
+// #pragma once
+
+// #include "types.hpp"
+// #include "well_known_symbols.hpp"
+// #include "values/object.hpp"
+// #include "any_value.hpp"
+
+// // We define the Symbol constructor function
+// inline auto symbolConstructor = [](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+//     std::string desc = "";
+//     if (!args.empty() && !args[0].is_undefined()) {
+//         desc = args[0].to_std_string();
+//     }
+//     return jspp::AnyValue::make_symbol(desc);
+// };
+
+// inline auto Symbol = jspp::AnyValue::make_function(symbolConstructor, "Symbol");
+
+// // Implementation of Symbol.for(key)
+// inline auto forFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+//     std::string key = "";
+//     if (!args.empty()) {
+//         key = args[0].to_std_string();
+//     }
+//     auto symPtr = jspp::JsSymbol::for_global(key);
+//     return jspp::AnyValue::from_symbol(symPtr);
+// }, "for");
+
+// // Implementation of Symbol.keyFor(sym)
+// inline auto keyForFn = jspp::AnyValue::make_function([](const std::vector<jspp::AnyValue>& args) -> jspp::AnyValue {
+//     if (args.empty() || !args[0].is_symbol()) {
+//         throw jspp::RuntimeError::make_error("Symbol.keyFor requires a symbol argument", "TypeError");
+//     }
+
+//     jspp::JsSymbol* sym = args[0].as_symbol();
+//     auto result = jspp::JsSymbol::key_for(sym);
+
+//     if (result.has_value()) {
+//         return jspp::AnyValue::make_string(result.value());
+//     } else {
+//         return jspp::AnyValue::make_undefined();
+//     }
+// }, "keyFor");
+
+// // Attach static properties/methods to the Symbol object
+// struct SymbolInit {
+//     SymbolInit() {
+//         Symbol.set_own_property("iterator", jspp::AnyValue::from_symbol(jspp::WellKnownSymbols::iterator));
+//         Symbol.set_own_property("for", forFn);
+//         Symbol.set_own_property("keyFor", keyForFn);
+//     }
+// } symbolInit;

package/src/prelude/log_string.hpp

@@ -26,6 +26,7 @@ namespace jspp
             const std::string RESET = "\033[0m";
             const std::string GREEN = "\033[32m";
             const std::string YELLOW = "\033[33m";
+            const std::string BLUE = "\033[94m";
             const std::string CYAN = "\033[36m";
             const std::string MAGENTA = "\033[35m";
             const std::string BRIGHT_BLACK = "\033[90m"; // Grey
@@ -90,9 +91,11 @@ namespace jspp
                 return Color::YELLOW + std::string(val.as_boolean() ? "true" : "false") + Color::RESET;
             if (val.is_number())
                 return Color::YELLOW + val.to_std_string() + Color::RESET;
+            if (val.is_symbol())
+                return Color::BLUE + val.to_std_string() + Color::RESET;
             if (val.is_string())
             {
-                const std::string &s = *val.as_string();
+                const std::string &s = val.as_string()->value;
                 if (depth == 0)
                     return truncate_string(s);
                 return Color::GREEN + std::string("\"") + truncate_string(s) + "\"" + Color::RESET;
@@ -100,8 +103,9 @@ namespace jspp
             if (val.is_function())
             {
                 auto fn = val.as_function();
+                auto type_part = fn->is_generator ? "GeneratorFunction" : "Function";
                 auto name_part = fn->name.size() > 0 ? ": " + fn->name : "";
-                return Color::CYAN + std::string("[Function") + name_part + "]" + Color::RESET;
+                return Color::CYAN + "[" + type_part + name_part + "]" + Color::RESET;
             }
 
             // Depth limit
@@ -137,12 +141,12 @@ namespace jspp
                 auto obj = val.as_object();
 
                 // If custom toString exists on the object, prefer it
-                auto itToString = obj->props.find(jspp::WellKnownSymbols::toString);
+                auto itToString = obj->props.find(jspp::WellKnownSymbols::toString->key);
                 if (itToString != obj->props.end() && itToString->second.is_function())
                 {
                     try
                     {
-                        auto result = itToString->second.as_function("toString")->call({});
+                        auto result = itToString->second.as_function()->call({});
                         return to_log_string(result, visited, depth);
                     }
                     catch (...)
@@ -230,12 +234,12 @@ namespace jspp
                 size_t item_count = static_cast<size_t>(arr->length);
 
                 // If custom toString exists on the object, prefer it
-                auto itToString = arr->props.find(jspp::WellKnownSymbols::toString);
+                auto itToString = arr->props.find(jspp::WellKnownSymbols::toString->key);
                 if (depth > 0 && itToString != arr->props.end() && itToString->second.is_function())
                 {
                     try
                     {
-                        auto result = itToString->second.as_function("toString")->call({});
+                        auto result = itToString->second.as_function()->call({});
                         return to_log_string(result, visited, depth);
                     }
                     catch (...)

package/src/prelude/operators.hpp

@@ -23,7 +23,7 @@ namespace jspp
                 return val.as_boolean() ? 1.0 : 0.0;
             if (val.is_string())
             {
-                const std::string &s = *val.as_string();
+                const std::string &s = val.as_string()->value;
                 // JS considers empty or whitespace-only strings as 0.
                 if (s.empty() || std::all_of(s.begin(), s.end(), isspace))
                     return 0.0;
@@ -116,7 +116,7 @@ namespace jspp
     {
         // Simplified Abstract Relational Comparison
         if (lhs.is_string() && rhs.is_string())
-            return AnyValue::make_boolean(*lhs.as_string() < *rhs.as_string());
+            return AnyValue::make_boolean(lhs.as_string()->value < rhs.as_string()->value);
 
         double l = Operators_Private::ToNumber(lhs);
         double r = Operators_Private::ToNumber(rhs);

package/src/prelude/types.hpp

@@ -6,6 +6,7 @@
 #include <variant>
 #include <functional>
 #include <memory>
+#include <map>
 #include <unordered_map>
 #include <algorithm>
 #include <cctype>
@@ -17,34 +18,51 @@
 // JSPP standard library
 namespace jspp
 {
-    // Forward declarations
+    // Js value forward declarations
     struct JsUndefined;     // cannot set property
     struct JsNull;          // cannot set property
     struct JsUninitialized; // cannot set property
+    struct JsString;        // can set property
     struct JsObject;        // can set property
     struct JsArray;         // can set property
     struct JsFunction;      // can set property
+    struct JsSymbol;        // can set property (but usually doesn't have own props)
+
+    template <typename T>
+    class JsIterator; // can set property
 
     // Object property configuration forward declarations
     struct DataDescriptor;
     struct AccessorDescriptor;
 
-    // Dynamic AnyValue
-    class AnyValue;
-
     // Custom runtime exception
     struct RuntimeError;
 
+    // Dynamic AnyValue
+    class AnyValue;
+
     // Arithemetic operators
     inline AnyValue pow(const AnyValue &lhs, const AnyValue &rhs);
 
     // AnyValue prototypes
     namespace StringPrototypes
     {
-        inline std::optional<AnyValue> get(const std::string &key, const std::unique_ptr<std::string> &self);
+        inline std::optional<AnyValue> get(const std::string &key, JsString *self);
     }
     namespace ArrayPrototypes
     {
         inline std::optional<AnyValue> get(const std::string &key, JsArray *self);
     }
-}
+    namespace FunctionPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsFunction *self);
+    }
+    namespace IteratorPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsIterator<AnyValue> *self);
+    }
+    namespace SymbolPrototypes
+    {
+        inline std::optional<AnyValue> get(const std::string &key, JsSymbol *self);
+    }
+}

package/src/prelude/values/array.hpp

@@ -5,6 +5,7 @@
 
 namespace jspp
 {
+    // Forward declaration of AnyValue
     class AnyValue;
 
     struct JsArray
@@ -18,6 +19,7 @@ namespace jspp
         explicit JsArray(const std::vector<std::optional<AnyValue>> &items) : dense(items), length(items.size()) {}
 
         std::string to_std_string() const;
+        JsIterator<AnyValue> get_iterator();
 
         AnyValue get_property(const std::string &key);
         AnyValue get_property(uint32_t idx);

package/src/prelude/values/function.hpp

@@ -4,15 +4,47 @@
 
 namespace jspp
 {
+    // Forward declaration of AnyValue
     class AnyValue;
 
+    using JsFunctionCallable = std::variant<std::function<AnyValue(const std::vector<AnyValue> &)>,                                // 0: Normal
+                                            std::function<jspp::JsIterator<jspp::AnyValue>(const std::vector<jspp::AnyValue> &)>>; // 1: Generator
+
     struct JsFunction
     {
-        std::function<AnyValue(const std::vector<AnyValue> &)> call;
+        JsFunctionCallable callable;
         std::string name;
         std::unordered_map<std::string, AnyValue> props;
+        bool is_generator;
+
+        // ---- Constructor A: infer is_generator using index() ----
+        JsFunction(const JsFunctionCallable &c,
+                   std::string n = {},
+                   std::unordered_map<std::string, AnyValue> p = {})
+            : callable(c),
+              name(std::move(n)),
+              props(std::move(p)),
+              is_generator(callable.index() == 1) // 1 = generator
+        {
+        }
+
+        // ---- Constructor B: explicitly set is_generator ----
+        JsFunction(const JsFunctionCallable &c,
+                   bool is_gen,
+                   std::string n = {},
+                   std::unordered_map<std::string, AnyValue> p = {})
+            : callable(c),
+              name(std::move(n)),
+              props(std::move(p)),
+              is_generator(is_gen)
+        {
+            // Optional debug check (no RTTI, no variant visitation):
+            // if (callable.index() == 1 && !is_gen) { ... }
+            // if (callable.index() == 0 && is_gen) { ... }
+        }
 
         std::string to_std_string() const;
+        AnyValue call(const std::vector<AnyValue> &args);
         AnyValue get_property(const std::string &key);
         AnyValue set_property(const std::string &key, const AnyValue &value);
     };