refactor(furvm): improve primitive types

Improve primitive types and binary operations.

Closes: #55

.clang-tidy

@@ -31,7 +31,9 @@ Checks: >
   -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-  -bugprone-forward-declaration-namespace
+  -cppcoreguidelines-use-enum-class,
+  -bugprone-forward-declaration-namespace,
+  -bugprone-tagged-union-member-count
 
 WarningsAsErrors: "*"
 

furvm/include/furvm/context.hpp

@@ -21,7 +21,8 @@ public:
     /**
      * @brief Constructs a context.
      */
-    context();
+    context()
+      : m_thingAllocator(m_thingArena) {}
 
     ~context() = default;
 
@@ -124,6 +125,8 @@ public:
      * @return The thing allocator.
      */
     thing_allocator<std::byte> thing_alloc() const { return m_thingAllocator; }
+
+    thing_type_store& thing_type_store() { return m_thingTypeStore; }
 private:
     handle_container<mod_h>      m_modules;
     handle_container<thing_h>    m_things;
@@ -131,6 +134,7 @@ private:
 
     furlang::arena             m_thingArena;
     thing_allocator<std::byte> m_thingAllocator;
+    class thing_type_store     m_thingTypeStore;
 };
 
 } // namespace furvm

furvm/include/furvm/executor.hpp

@@ -164,6 +164,10 @@ public:
      * @brief Executes next instruction.
      */
     void step();
+private:
+    thing_type thing_type_impl(mod_h mod, mod_type type) const;
+
+    thing_type* thing_type(const mod_h& mod, const mod_type& type) const;
 private:
     executor_flags m_flags{}; // NOLINT(bugprone-invalid-enum-default-initialization)
     context_p      m_context;

furvm/include/furvm/function.hpp

@@ -37,7 +37,7 @@ struct import_function {
  * @brief Function signature.
  */
 struct function_sig {
-    std::vector<type_h> params;
+    std::vector<mod_type_h> params;
 
     bool operator==(const function_sig& rhs) const { return params == rhs.params; }
 
@@ -190,9 +190,7 @@ private:
 namespace detail {
 
 struct function_sig_hash {
-    std::size_t operator()(const function_sig& signature) const {
-        return furlang::utility::vector_hash<type_h, detail::handle_hash<type_h>>{}(signature.params);
-    }
+    std::size_t operator()(const function_sig& signature) const;
 };
 
 } // namespace detail

furvm/include/furvm/fwd.hpp

@@ -115,6 +115,12 @@ using function_h = handle<function, refcount_header<function_id>>;
 
 // module.hpp
 
+struct mod_type;
+
+using mod_type_id = std::uint32_t;
+
+using mod_type_h = handle<mod_type, generic_header<mod_type_id>>;
+
 /**
  * @class mod
  * @brief Module.
@@ -138,34 +144,20 @@ using mod_id = std::string;
  */
 using mod_h = handle<mod, refcount_header<mod_id>>;
 
+// thing_allocator.hpp
+
+template <typename T>
+class thing_allocator;
+
 // thing.hpp
 
-/**
- * @enum type_t
- * @brief Type of the thing's type.
- */
-enum class type_t : std::uint32_t;
-
-/**
- * @struct type
- * @brief Thing type.
- */
-struct type;
-
-using type_p = std::shared_ptr<type>;
-
-using type_id = std::uint32_t;
-
-using type_h = handle<type_p, generic_header<type_id>>;
-
 /**
  * @class bad_thing_access
  * @brief Bad thing access exception.
  */
 class bad_thing_access;
 
-template <typename T>
-class thing_allocator;
+using thing_type_id = std::uint32_t;
 
 /**
  * @class thing

furvm/include/furvm/module.hpp

@@ -5,7 +5,6 @@
 #include "furvm/function.hpp"
 #include "furvm/fwd.hpp"
 #include "furvm/handle.hpp"
-#include "furvm/type.hpp" // IWYU pragma: keep
 
 #include <functional>
 #include <istream>
@@ -18,6 +17,120 @@
 
 namespace furvm {
 
+struct mod_type {
+    struct array {
+        mod_type_id typeId;
+        std::size_t size;
+    };
+
+    struct imprt {
+        mod_id      modId;
+        mod_type_id typeId;
+    };
+
+    enum type {
+        S8 = 0,
+        S16,
+        S32,
+        S64,
+        U8,
+        U16,
+        U32,
+        U64,
+        Array,
+
+        Import,
+        Count,
+    } type;
+    union value {
+        std::nullptr_t null = nullptr;
+        array          array;
+        imprt          imprt;
+
+        value() = default;
+
+        value(mod_type_id id, std::size_t size)
+          : array({}) {
+            array.typeId = id;
+            array.size   = size;
+        }
+
+        template <typename ModIdFwd, typename = std::enable_if_t<std::is_constructible_v<mod_id, ModIdFwd>>>
+        value(ModIdFwd&& modId, mod_type_id typeId)
+          : imprt({}) {
+            imprt.modId  = std::forward<ModIdFwd>(modId);
+            imprt.typeId = typeId;
+        }
+
+        ~value() {}
+
+        value(value&& other)                 = delete;
+        value& operator=(value&& other)      = delete;
+        value(const value& other)            = delete;
+        value& operator=(const value& other) = delete;
+    } value;
+
+    mod_type(enum type type)
+      : type(type) {}
+
+    mod_type(mod_type_id id, std::size_t size)
+      : type(Array), value(id, size) {}
+
+    template <typename ModIdFwd, typename = std::enable_if_t<std::is_constructible_v<mod_id, ModIdFwd>>>
+    mod_type(ModIdFwd&& modId, mod_type_id typeId)
+      : type(Import), value(std::forward<ModIdFwd>(modId), typeId) {}
+
+    ~mod_type() {
+        switch (type) {
+        case Array: value.array.~array(); break;
+        case Import: value.imprt.~imprt(); break;
+        default: break;
+        }
+    }
+
+    mod_type(mod_type&& other) noexcept
+      : type(other.type) {
+        switch (type) {
+        case Array: new (&value.array) array(other.value.array); break;
+        case Import: new (&value.imprt) imprt(std::move(other.value.imprt)); break;
+        default: break;
+        }
+        other.type = Count;
+    }
+
+    mod_type& operator=(mod_type&& other) noexcept {
+        if (this == &other) return *this;
+        type = other.type;
+        switch (type) {
+        case Array: new (&value.array) array(other.value.array); break;
+        case Import: new (&value.imprt) imprt(std::move(other.value.imprt)); break;
+        default: break;
+        }
+        other.type = Count;
+        return *this;
+    }
+
+    mod_type(const mod_type& other)
+      : type(other.type) {
+        switch (type) {
+        case Array: new (&value.array) array(other.value.array); break;
+        case Import: new (&value.imprt) imprt(other.value.imprt); break;
+        default: break;
+        }
+    }
+
+    mod_type& operator=(const mod_type& other) {
+        if (this == &other) return *this;
+        type = other.type;
+        switch (type) {
+        case Array: new (&value.array) array(other.value.array); break;
+        case Import: new (&value.imprt) imprt(other.value.imprt); break;
+        default: break;
+        }
+        return *this;
+    }
+};
+
 class mod {
     friend class function;
     friend class serializer;
@@ -181,7 +294,7 @@ public:
      */
     template <typename... Args>
     auto emplace_type(Args&&... args) {
-        if constexpr (std::is_constructible_v<type_p, Args...>) {
+        if constexpr (std::is_constructible_v<mod_type, Args...>) {
             return m_types.emplace_back(std::forward<Args>(args)...);
         } else {
             return m_types.emplace(std::forward<Args>(args)...);
@@ -245,7 +358,7 @@ private:
     std::unordered_map<function_id, pair_type>            m_functionMap;
     handle_container<function_h>                          m_functions;
 
-    handle_container<type_h> m_types;
+    handle_container<mod_type_h> m_types;
 
     std::unordered_map<std::string, native_function> m_nativeFunctions;
 };

furvm/include/furvm/thing.hpp

@@ -1,38 +1,194 @@
 #ifndef FURVM_THING_HPP
 #define FURVM_THING_HPP
 
+#include "furlang/arena.hpp"
+#include "furlang/utility/hash.hpp"
 #include "furvm/exceptions.hpp"
 #include "furvm/fwd.hpp"
-#include "furvm/module.hpp"
-#include "furvm/type.hpp"
+#include "furvm/thing_allocator.hpp" // IWYU pragma: keep
 
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
 #include <functional>
-#include <memory>
+#include <limits>
 #include <new>
 #include <stdexcept>
+#include <type_traits>
+#include <unordered_map>
 #include <utility>
 
 namespace furvm {
 
+struct thing_type {
+    using s8  = std::int8_t;
+    using s16 = std::int16_t;
+    using s32 = std::int32_t;
+    using s64 = std::int64_t;
+    using u8  = std::uint8_t;
+    using u16 = std::uint16_t;
+    using u32 = std::uint32_t;
+    using u64 = std::uint64_t;
+
+    struct array {
+        thing_type* type;
+        std::size_t size;
+    };
+
+    enum type { // NOLINT
+        S8 = 0,
+        S16,
+        S32,
+        S64,
+        U8,
+        U16,
+        U32,
+        U64,
+        Array,
+
+        Count,
+    } type;
+    union value {
+        std::nullptr_t null = nullptr;
+        array          array;
+
+        value() = default;
+
+        value(thing_type* type, std::size_t size)
+          : array({}) {
+            array.type = type;
+            array.size = size;
+        }
+    } value;
+
+    static constexpr thing_type_id INVALID_ID = std::numeric_limits<thing_type_id>::max();
+
+    thing_type_id id = INVALID_ID;
+
+    bool operator==(const thing_type& other) const {
+        if (type != other.type) return false;
+        switch (type) {
+        case S8:
+        case S16:
+        case S32:
+        case S64:
+        case U8:
+        case U16:
+        case U32:
+        case U64: return true;
+        case Array: return *value.array.type == *other.value.array.type && value.array.size == other.value.array.size;
+        case Count: break;
+        }
+        return false;
+    }
+
+    bool operator!=(const thing_type& other) const { return !this->operator==(other); }
+
+    static bool is_primitive(enum type type) {
+        switch (type) {
+        case S8:
+        case S16:
+        case S32:
+        case S64:
+        case U8:
+        case U16:
+        case U32:
+        case U64: return true;
+        case Array:
+        case Count: break;
+        }
+        return false;
+    }
+
+    static std::size_t primitive_size(enum type type) {
+        switch (type) {
+        case thing_type::S8: return sizeof(s8);
+        case thing_type::S16: return sizeof(s16);
+        case thing_type::S32: return sizeof(s32);
+        case thing_type::S64: return sizeof(s64);
+        case thing_type::U8: return sizeof(u8);
+        case thing_type::U16: return sizeof(u16);
+        case thing_type::U32: return sizeof(u32);
+        case thing_type::U64: return sizeof(u64);
+        case Array:
+        case Count: break;
+        }
+        return 0;
+    }
+};
+
+namespace detail {
+
+struct thing_type_hash {
+    std::size_t operator()(const thing_type& type) const {
+        std::size_t seed = std::hash<decltype(type.type)>{}(type.type);
+        switch (type.type) {
+        case thing_type::S8:
+        case thing_type::S16:
+        case thing_type::S32:
+        case thing_type::S64:
+        case thing_type::U8:
+        case thing_type::U16:
+        case thing_type::U32:
+        case thing_type::U64: return seed;
+        case thing_type::Array:
+            seed = furlang::utility::hash_combine(seed, thing_type_hash{}(*type.value.array.type));
+            seed = furlang::utility::hash_combine(seed,
+                std::hash<decltype(type.value.array.size)>{}(type.value.array.size));
+            return seed;
+        case thing_type::Count: break;
+        }
+        throw std::runtime_error("unreachable");
+    }
+};
+
+} // namespace detail
+
+class thing_type_store {
+public:
+    thing_type* insert(thing_type& type) {
+        if (auto it = m_typeMap.find(type); it != m_typeMap.end()) return m_map[type.id = it->second];
+        if (type.id == thing_type::INVALID_ID) type.id = m_counter++;
+
+        thing_type* ptr = m_arena.allocate<thing_type>(type);
+        m_map[type.id]  = ptr;
+        m_typeMap[type] = type.id;
+        return ptr;
+    }
+
+    thing_type* at(thing_type_id id) const {
+        if (auto it = m_map.find(id); it != m_map.end()) return it->second;
+        return nullptr;
+    }
+private:
+    furlang::arena                                                         m_arena;
+    std::unordered_map<thing_type_id, thing_type*>                         m_map;
+    std::unordered_map<thing_type, thing_type_id, detail::thing_type_hash> m_typeMap;
+    thing_type_id                                                          m_counter = 0;
+};
+
 template <template <typename> typename Allocator>
 class thing final {
     friend class executor;
 public:
     using allocator_type = Allocator<std::byte>; /**< Allocator type. */
-
-    using mod_container = std::shared_ptr<handle_container<mod_h>>;
+public:
+    union array {
+        std::byte flat[];
+        struct {
+            std::size_t size;
+            std::byte*  data;
+        } dynamic;
+    };
 public:
     /**
      * @brief Constructs a thing.
      *
-     * @param type Thing type reference.
+     * @param type Thing type.
      * @param allocator Allocator for the thing's data.
      */
-    thing(const type_ref& type, const mod_container& modules = nullptr, const allocator_type& allocator = {})
-      : m_type(type), m_size(compute_size(resolve_type(type, modules))), m_modules(modules), m_allocator(allocator) {
+    thing(const thing_type& type, const allocator_type& allocator = {})
+      : m_type(type), m_size(compute_size(type)), m_allocator(allocator) {
         // TODO: Account for alignment
         m_data = m_allocator.allocate(m_size);
         std::memset(m_data, 0, m_size);
@@ -49,12 +205,8 @@ public:
      * @brief Move constructor.
      */
     thing(thing&& other) noexcept
-      : m_type(std::move(other.m_type)),
-        m_data(other.m_data),
-        m_size(other.m_size),
-        m_modules(std::move(other.m_modules)),
-        m_allocator(std::move(other.m_allocator)) {
-        other.m_type = {};
+      : m_type(other.m_type), m_data(other.m_data), m_size(other.m_size), m_allocator(std::move(other.m_allocator)) {
+        other.m_type.type = thing_type::Count;
         other.m_data      = nullptr;
         other.m_size      = 0;
     }
@@ -66,9 +218,8 @@ public:
         if (this == &other) return *this;
         m_type            = other.m_type;
         m_data            = other.m_data;
-        m_modules    = std::move(other.m_modules);
         m_allocator       = std::move(other.m_allocator);
-        other.m_type = {};
+        other.m_type.type = thing_type::Count;
         other.m_data      = nullptr;
         other.m_size      = 0;
         return *this;
@@ -76,8 +227,6 @@ public:
 
     thing(const thing&)            = delete;
     thing& operator=(const thing&) = delete;
-public:
-    void assign_mod_container(const mod_container& modules) { m_modules = modules; }
 public:
     /**
      * @brief Returns a clone of the thing.
@@ -85,30 +234,24 @@ public:
      * @return A clone of this thing.
      */
     thing clone() const {
-        auto type = resolve_type(m_type, m_modules);
-        if (m_size == 0) {
-            return reference();
-        }
+        if (m_size == 0) return reference();
 
-        thing res(type, m_modules, m_allocator);
-        switch (type->t) {
-        case type_t::Primitive:
-        case type_t::Array: {
-            copy_list(*type.type, res.get<array_t>(), get<array_t>());
-        } break;
-        case type_t::Import:
-        default: throw std::runtime_error("unreachable");
+        thing res(m_type, m_allocator);
+        switch (m_type.type) {
+        case thing_type::S8:
+        case thing_type::S16:
+        case thing_type::S32:
+        case thing_type::S64:
+        case thing_type::U8:
+        case thing_type::U16:
+        case thing_type::U32:
+        case thing_type::U64: std::memcpy(res.m_data, m_data, m_size); return std::move(res);
+        case thing_type::Array: copy_list(m_type, res.get<array>(), get<array>()); return std::move(res);
+        case thing_type::Count: break;
         }
-        return std::move(res);
+        throw std::runtime_error("unreachable");
     }
 public:
-    /**
-     * @brief Returns the thing's type reference.
-     *
-     * @return The type reference.
-     */
-    auto type() { return m_type; }
-
     /**
      * @brief Returns the thing's type reference.
      *
@@ -137,8 +280,7 @@ public:
      */
     template <typename T>
     T& get() {
-        std::size_t size = m_size > 0 ? m_size : compute_size_na(resolve_type(m_type, m_modules));
-        if (size != sizeof(T)) throw bad_thing_access();
+        if (compute_size_na(m_type) != sizeof(T)) throw bad_thing_access();
         return *std::launder(reinterpret_cast<T*>(m_data));
     }
 
@@ -149,8 +291,7 @@ public:
      */
     template <typename T>
     const T& get() const {
-        std::size_t size = m_size > 0 ? m_size : compute_size_na(resolve_type(m_type, m_modules));
-        if (size != sizeof(T)) throw bad_thing_access();
+        if (compute_size_na(m_type) != sizeof(T)) throw bad_thing_access();
         return *std::launder(reinterpret_cast<const T*>(m_data));
     }
 public:
@@ -247,79 +388,76 @@ public:
      *
      * @return The integer value.
      */
-    long_t integer() const {
-        if (m_type->t != type_t::Primitive) throw bad_thing_access();
-        switch (m_type->primitive) {
-        case sizeof(byte_t): return get<byte_t>();
-        case sizeof(short_t): return get<short_t>();
-        case sizeof(int_t): return get<int_t>();
-        case sizeof(long_t): return get<long_t>();
+    thing_type::s64 integer() const {
+        switch (m_type.type) {
+        case thing_type::S8: return get<thing_type::s8>();
+        case thing_type::S16: return get<thing_type::s16>();
+        case thing_type::S32: return get<thing_type::s32>();
+        case thing_type::S64: return get<thing_type::s64>();
+        case thing_type::U8: return get<thing_type::u8>();
+        case thing_type::U16: return get<thing_type::u16>();
+        case thing_type::U32: return get<thing_type::u32>();
+        case thing_type::U64: return get<thing_type::u64>();
         default: throw std::runtime_error("unreachable");
         }
     }
 
-    thing reference() const { return { m_type, m_data, m_modules, m_allocator }; }
+    thing reference() const { return { m_type, m_data, m_allocator }; }
 
     constexpr bool is_reference() const { return m_size == 0; }
 
-    void resize(long_t newSize) {
-        if (m_type->t != type_t::Array) throw bad_thing_access();
-        if (m_type->array.size > 0) throw std::runtime_error("cannot resize a static array");
+    void resize(thing_type::u64 newSize) {
+        if (m_type.type != thing_type::Array) throw bad_thing_access();
+        if (m_type.value.array.size > 0) throw std::runtime_error("cannot resize a static array");
 
-        auto& array = get<array_t>();
+        auto& array = get<union array>();
         if (newSize < 0 || newSize == array.dynamic.size) return;
-        std::size_t innerSize = compute_size_na(*m_type->array.type);
+        std::size_t innerSize = compute_size_na(*m_type.value.array.type);
         std::byte*  newData   = new std::byte[innerSize * newSize];
-        std::memcpy(newData, array.dynamic.data, innerSize * std::min(array.dynamic.size, newSize));
+        std::memcpy(newData,
+            array.dynamic.data,
+            innerSize * std::min(static_cast<thing_type::u64>(array.dynamic.size), newSize));
         array.dynamic.size = newSize;
         delete[] array.dynamic.data;
         array.dynamic.data = newData;
     }
 
-    thing at(long_t index) const {
-        if (m_type->t != type_t::Array) throw bad_thing_access();
+    thing at(thing_type::u64 index) const {
+        if (m_type.type != thing_type::Array) throw bad_thing_access();
 
-        std::size_t elementSize = compute_size_na(*m_type->array.type);
-        if (m_type->array.size == 0) {
-            auto& array = get<array_t>();
+        std::size_t elementSize = compute_size_na(*m_type.value.array.type);
+        if (m_type.value.array.size == 0) {
+            auto& array = get<union array>();
             if (index < 0 || index >= array.dynamic.size) throw std::out_of_range("index out of range");
-            return { { m_type.mod, m_type->array.type },
-                array.dynamic.data + (index * elementSize),
-                m_modules,
-                m_allocator };
+            return { *m_type.value.array.type, array.dynamic.data + (index * elementSize), m_allocator };
         }
 
-        std::byte* data = reinterpret_cast<array_t*>(m_data)->data;
-        if (index < 0 || index >= m_type->array.size) throw std::out_of_range("index out of range");
-        return { { m_type.mod, m_type->array.type }, data + (index * elementSize), m_modules, m_allocator };
+        std::byte* data = reinterpret_cast<array*>(m_data)->flat;
+        if (index < 0 || index >= m_type.value.array.size) throw std::out_of_range("index out of range");
+        return { *m_type.value.array.type, data + (index * elementSize), m_allocator };
     }
 
     std::size_t size() const {
-        if (m_type->t != type_t::Array) throw std::runtime_error("not an array");
-        if (m_type->array.size == 0) return get<array_t>().dynamic.size;
-        return m_type->array.size;
+        if (m_type.type != thing_type::Array) throw bad_thing_access();
+        return m_type.value.array.size == 0 ? get<array>().dynamic.size : m_type.value.array.size;
     }
-public:
-    static type_ref resolve_type(const type_ref& initType, const mod_container& modules) {
-        type_ref rsv = initType;
-        while (rsv->t == type_t::Import) {
-            auto mod = modules->at(initType->imp.mod);
-            rsv      = type_ref{ mod, mod->type_at(initType->imp.type) };
-        }
-        return rsv;
+
+    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
+    T cast_to() const {
+        return visit_primitive([](auto value) { return static_cast<T>(value); });
     }
 private:
-    static void copy_list(const type_p& arrayType, array_t& dst, const array_t& src) {
-        if (arrayType == nullptr || arrayType->t != type_t::Array || *arrayType->array.type == nullptr)
+    static void copy_list(const thing_type& arrayType, array& dst, const array& src) {
+        if (arrayType.type != thing_type::Array || arrayType.value.array.type == nullptr)
             throw std::runtime_error("invalid type");
 
-        auto        innerType   = *arrayType->array.type;
+        const auto& innerType   = *arrayType.value.array.type;
         std::size_t elementSize = compute_size_na(innerType);
 
         std::byte*       data    = nullptr;
         const std::byte* srcData = nullptr;
         std::size_t      size    = 0;
-        if (arrayType->array.size == 0) {
+        if (arrayType.value.array.size == 0) {
             size = dst.dynamic.size = src.dynamic.size;
             if (dst.dynamic.size < 0) {
                 dst.dynamic.data = nullptr;
@@ -329,73 +467,191 @@ private:
             srcData = src.dynamic.data;
             data = dst.dynamic.data = new std::byte[dst.dynamic.size];
         } else {
-            data    = dst.data;
-            srcData = src.data;
-            size    = arrayType->array.size;
+            data    = dst.flat;
+            srcData = src.flat;
+            size    = arrayType.value.array.size;
         }
 
-        switch (innerType->t) {
-        case type_t::Primitive: std::memcpy(dst.data, src.data, size); break;
-        case type_t::Array:
+        switch (innerType.type) {
+        case thing_type::S8:
+        case thing_type::S16:
+        case thing_type::S32:
+        case thing_type::S64:
+        case thing_type::U8:
+        case thing_type::U16:
+        case thing_type::U32:
+        case thing_type::U64: std::memcpy(dst.flat, src.flat, size); return;
+        case thing_type::Array:
             for (std::size_t i = 0; i < size; ++i) {
-                copy_list(*innerType->array.type,
-                    *std::launder(reinterpret_cast<array_t*>(data + (i * elementSize))),
-                    *std::launder(reinterpret_cast<const array_t*>(srcData + (i * elementSize))));
+                copy_list(*innerType.value.array.type,
+                    *std::launder(reinterpret_cast<array*>(data + (i * elementSize))),
+                    *std::launder(reinterpret_cast<const array*>(srcData + (i * elementSize))));
             }
-            break;
-        case type_t::Import: throw std::runtime_error("unresolved type");
+            return;
+        case thing_type::Count: break;
         }
+        throw std::runtime_error("unreachable");
     }
 private:
-    static std::size_t compute_size_na(const type_p& type) {
-        switch (type->t) {
-        case type_t::Primitive: return type->primitive;
-        case type_t::Array: {
-            if (type->array.size == 0) return sizeof(array_t);
-            return compute_size_na(*type->array.type) * type->array.size;
-        }
-        case type_t::Import: throw std::runtime_error("unresolved type");
+    static std::size_t compute_size_na(const thing_type& type) {
+        switch (type.type) {
+        case thing_type::S8: return sizeof(thing_type::s8);
+        case thing_type::S16: return sizeof(thing_type::s16);
+        case thing_type::S32: return sizeof(thing_type::s32);
+        case thing_type::S64: return sizeof(thing_type::s64);
+        case thing_type::U8: return sizeof(thing_type::u8);
+        case thing_type::U16: return sizeof(thing_type::u16);
+        case thing_type::U32: return sizeof(thing_type::u32);
+        case thing_type::U64: return sizeof(thing_type::u64);
+        case thing_type::Array:
+            return type.value.array.size == 0 ? sizeof(array)
+                                              : compute_size_na(*type.value.array.type) * type.value.array.size;
+        case thing_type::Count: break;
         }
 
         throw std::runtime_error("unreachable");
     }
 
-    static std::size_t compute_size_na(const type_ref& type) { return compute_size_na(*type.type); }
-
     // NOTE: Align to 4 bytes
-    static std::size_t compute_size(const type_p& type) { return (compute_size_na(type) + 3) & ~3; }
-    static std::size_t compute_size(const type_ref& type) { return compute_size(*type.type); }
+    static std::size_t compute_size(const thing_type& type) { return (compute_size_na(type) + 3) & ~3; }
 private:
-    thing(const type_ref& type, std::byte* data, const mod_container& modules, const allocator_type& allocator = {})
-      : m_type(type), m_size(0), m_data(data), m_modules(modules), m_allocator(allocator) {}
+    thing(const thing_type& type, std::byte* data, const allocator_type& allocator = {})
+      : m_type(type), m_size(0), m_data(data), m_allocator(allocator) {}
 private:
+    template <typename Func>
+    decltype(auto) visit_primitive(Func&& func) const {
+        switch (m_type.type) {
+        case thing_type::S8: return std::forward<Func>(func)(get<thing_type::s8>());
+        case thing_type::S16: return std::forward<Func>(func)(get<thing_type::s16>());
+        case thing_type::S32: return std::forward<Func>(func)(get<thing_type::s32>());
+        case thing_type::S64: return std::forward<Func>(func)(get<thing_type::s64>());
+        case thing_type::U8: return std::forward<Func>(func)(get<thing_type::u8>());
+        case thing_type::U16: return std::forward<Func>(func)(get<thing_type::u16>());
+        case thing_type::U32: return std::forward<Func>(func)(get<thing_type::u32>());
+        case thing_type::U64: return std::forward<Func>(func)(get<thing_type::u64>());
+        default: throw bad_thing_access();
+        }
+    }
+
     template <typename Op>
     thing binary_op(const thing& rhs, const Op& op) const {
-        if (m_type->t == type_t::Primitive && rhs.type()->t == type_t::Primitive) {
-            type_ref    type = m_type->primitive >= rhs.type()->primitive ? m_type : rhs.type();
-            std::size_t size = std::max(m_type->primitive, rhs.type()->primitive);
+        if (thing_type::is_primitive(m_type.type) && thing_type::is_primitive(rhs.m_type.type)) {
+            static constexpr enum thing_type::type promotions[8 * 8] = {
+                // S8
+                thing_type::S8,
+                thing_type::S16,
+                thing_type::S32,
+                thing_type::S64,
+                thing_type::S16,
+                thing_type::S16,
+                thing_type::S32,
+                thing_type::U64,
+                // S16
+                thing_type::S16,
+                thing_type::S16,
+                thing_type::S32,
+                thing_type::S64,
+                thing_type::S16,
+                thing_type::S16,
+                thing_type::S32,
+                thing_type::U64,
+                // S32
+                thing_type::S32,
+                thing_type::S32,
+                thing_type::S32,
+                thing_type::S64,
+                thing_type::S32,
+                thing_type::S32,
+                thing_type::U32,
+                thing_type::U64,
+                // S64
+                thing_type::S64,
+                thing_type::S64,
+                thing_type::S64,
+                thing_type::S64,
+                thing_type::S64,
+                thing_type::S64,
+                thing_type::S64,
+                thing_type::U64,
+                // U8
+                thing_type::S16,
+                thing_type::S16,
+                thing_type::S32,
+                thing_type::S64,
+                thing_type::U8,
+                thing_type::U16,
+                thing_type::U32,
+                thing_type::U64,
+                // U16
+                thing_type::S16,
+                thing_type::S16,
+                thing_type::S32,
+                thing_type::S64,
+                thing_type::U16,
+                thing_type::U16,
+                thing_type::U32,
+                thing_type::U64,
+                // U32
+                thing_type::S32,
+                thing_type::S32,
+                thing_type::U32,
+                thing_type::S64,
+                thing_type::U32,
+                thing_type::U32,
+                thing_type::U32,
+                thing_type::U64,
+                // U64
+                thing_type::U64,
+                thing_type::U64,
+                thing_type::U64,
+                thing_type::U64,
+                thing_type::U64,
+                thing_type::U64,
+                thing_type::U64,
+                thing_type::U64,
+            };
 
-            long_t result = op(integer(), rhs.integer());
+            enum thing_type::type resultType = promotions[m_type.type + (rhs.m_type.type * 8)];
 
-            thing res(type, m_modules, m_allocator);
-            switch (size) {
-            case sizeof(byte_t): res.get<byte_t>() = result; break;
-            case sizeof(short_t): res.get<short_t>() = result; break;
-            case sizeof(int_t): res.get<int_t>() = result; break;
-            case sizeof(long_t): res.get<long_t>() = result; break;
-            default: throw std::runtime_error("unreachable");
+            thing res = { thing_type{ resultType }, m_allocator };
+            switch (resultType) {
+            case thing_type::S8:
+                res.get<thing_type::s8>() = Op{}(cast_to<thing_type::s8>(), rhs.cast_to<thing_type::s8>());
+                return res;
+            case thing_type::S16:
+                res.get<thing_type::s16>() = Op{}(cast_to<thing_type::s16>(), rhs.cast_to<thing_type::s16>());
+                return res;
+            case thing_type::S32:
+                res.get<thing_type::s32>() = Op{}(cast_to<thing_type::s32>(), rhs.cast_to<thing_type::s32>());
+                return res;
+            case thing_type::S64:
+                res.get<thing_type::s64>() = Op{}(cast_to<thing_type::s64>(), rhs.cast_to<thing_type::s64>());
+                return res;
+            case thing_type::U8:
+                res.get<thing_type::u8>() = Op{}(cast_to<thing_type::u8>(), rhs.cast_to<thing_type::u8>());
+                return res;
+            case thing_type::U16:
+                res.get<thing_type::u16>() = Op{}(cast_to<thing_type::u16>(), rhs.cast_to<thing_type::u16>());
+                return res;
+            case thing_type::U32:
+                res.get<thing_type::u32>() = Op{}(cast_to<thing_type::u32>(), rhs.cast_to<thing_type::u32>());
+                return res;
+            case thing_type::U64:
+                res.get<thing_type::u64>() = Op{}(cast_to<thing_type::u64>(), rhs.cast_to<thing_type::u64>());
+                return res;
+            case thing_type::Array:
+            case thing_type::Count: break;
             }
-            return std::move(res);
+            throw std::runtime_error("unreachable");
         }
 
         throw std::runtime_error("unexpected operation");
     }
 private:
-    type_ref    m_type;
+    thing_type  m_type;
     std::size_t m_size;
     std::byte*  m_data;
 
-    mod_container  m_modules;
     allocator_type m_allocator;
 };
 

furvm/include/furvm/type.hpp

@@ -1,181 +0,0 @@
-#ifndef FURVM_TYPE_HPP
-#define FURVM_TYPE_HPP
-
-#include "furvm/fwd.hpp"
-#include "furvm/handle.hpp" // IWYU pragma: keep
-
-#include <cstdint>
-#include <stdexcept>
-
-namespace furvm {
-
-enum class type_t : std::uint32_t {
-    Primitive = 0,
-    Array,
-
-    Import,
-};
-
-using primitive_type = std::uint64_t;
-
-/**
- * @brief Array type.
- */
-struct array_type {
-    type_h type; /**< Type of the array's elements. */
-
-    /**
-     * @brief Size of the array.
-     *
-     * Size of the array. If size is equal to zero, then the array becomes dynamic.
-     */
-    std::size_t size;
-
-    bool operator==(const array_type& rhs) const { return type == rhs.type && size == rhs.size; }
-    bool operator!=(const array_type& rhs) const { return !this->operator==(rhs); }
-};
-
-struct import_type {
-    mod_id  mod;
-    type_id type;
-
-    bool operator==(const import_type& rhs) const { return mod == rhs.mod && type == rhs.type; }
-    bool operator!=(const import_type& rhs) const { return !this->operator==(rhs); }
-};
-
-struct type {
-    type_t t;
-    union {
-        primitive_type primitive{};
-        array_type     array;
-        import_type    imp;
-    };
-
-    type(type_t type)
-      : t(type) {}
-
-    type(primitive_type primitive)
-      : t(type_t::Primitive), primitive(primitive) {}
-
-    type(const type_h& type, std::size_t size = 0)
-      : t(type_t::Array), array(array_type{ type, size }) {}
-
-    type(const array_type& list)
-      : t(type_t::Array), array(list) {}
-
-    type(const import_type& imp)
-      : t(type_t::Import), imp(imp) {}
-
-    ~type() {
-        switch (t) {
-        case type_t::Array: array.~array_type(); break;
-        case type_t::Import: imp.~import_type(); break;
-        default: break;
-        }
-    }
-
-    type(type&& other) noexcept
-      : t(other.t) {
-        switch (t) {
-        case type_t::Primitive: primitive = other.primitive; break;
-        case type_t::Array: array = std::move(other.array); break;
-        case type_t::Import: imp = std::move(other.imp); break;
-        }
-    }
-
-    type& operator=(type&& other) noexcept {
-        if (this == &other) return *this;
-        t = other.t;
-        switch (t) {
-        case type_t::Primitive: primitive = other.primitive; break;
-        case type_t::Array: array = std::move(other.array); break;
-        case type_t::Import: imp = std::move(other.imp); break;
-        }
-
-        return *this;
-    }
-
-    type(const type& other)
-      : t(other.t) {
-        switch (t) {
-        case type_t::Primitive: primitive = other.primitive; break;
-        case type_t::Array: array = other.array; break;
-        case type_t::Import: imp = other.imp; break;
-        }
-    }
-
-    type& operator=(const type& other) {
-        if (this == &other) return *this;
-        t = other.t;
-        switch (t) {
-        case type_t::Primitive: primitive = other.primitive; break;
-        case type_t::Array: array = other.array; break;
-        case type_t::Import: imp = other.imp; break;
-        }
-
-        return *this;
-    }
-
-    bool operator==(const type& rhs) const {
-        if (t != rhs.t) return false;
-        switch (t) {
-        case type_t::Primitive: return primitive == rhs.primitive;
-        case type_t::Array: return array == rhs.array;
-        case type_t::Import: return imp == rhs.imp;
-        }
-        throw std::runtime_error("unreachable");
-    }
-
-    bool operator!=(const type& rhs) const { return !this->operator==(rhs); }
-};
-
-using byte_t  = std::int8_t;  /**< A 1-byte integer. */
-using short_t = std::int16_t; /**< A 2-byte integer. */
-using int_t   = std::int32_t; /**< A 4-byte integer. */
-using long_t  = std::int64_t; /**< An 8-byte integer. */
-
-/**
- * @brief Array type's data layout.
- */
-union array_t {
-    std::byte data[]; /**< Static array's elements' data. */
-    struct {
-        long_t     size; /**< Size of the array (in items). */
-        std::byte* data; /**< Pointer to dynamic array's elements' data array. */
-    } dynamic;           /**< Dynamic array's info. */
-};
-
-/**
- * @brief A 1-byte integer thing type.
- */
-inline static type byteType = { sizeof(byte_t) }; // NOLINT
-
-/**
- * @brief A 2-byte integer thing type.
- */
-inline static type shortType = { sizeof(short_t) }; // NOLINT
-
-/**
- * @brief A 4-byte integer thing type.
- */
-inline static type intType = { sizeof(int_t) }; // NOLINT
-
-/**
- * @brief An 8-byte integer thing type.
- */
-inline static type longType = { sizeof(long_t) }; // NOLINT
-
-/**
- * @brief Reference to a type.
- */
-struct type_ref {
-    mod_h  mod;
-    type_h type;
-
-    class type*       operator->() { return &**type; }
-    const class type* operator->() const { return &**type; }
-};
-
-} // namespace furvm
-
-#endif // FURVM_TYPE_HPP

furvm/src/context.cpp

@@ -1,24 +0,0 @@
-#include "furvm/context.hpp"
-
-#include "furvm/thing.hpp" // IWYU pragma: keep
-#include "furvm/type.hpp"
-
-#include <cstdint>
-#include <memory>
-
-namespace furvm {
-
-context::context()
-  : m_thingAllocator(m_thingArena) {
-    mod core;
-    core.emplace_type(std::make_shared<type>(byteType));
-    core.emplace_type(std::make_shared<type>(shortType));
-    core.emplace_type(std::make_shared<type>(intType));
-    core.emplace_type(std::make_shared<type>(longType));
-    static_assert(sizeof(std::uintptr_t) == 8, "Unsupported platform");
-    core.emplace_type(*core.type_at(3));
-
-    emplace("core", std::move(core)).dispatch();
-}
-
-} // namespace furvm

furvm/src/executor.cpp

@@ -6,14 +6,42 @@
 #include "furvm/fwd.hpp"
 #include "furvm/instruction.hpp"
 #include "furvm/thing.hpp"
-#include "furvm/type.hpp"
 
+#include <cassert>
 #include <cstdint>
 #include <stdexcept>
 #include <vector>
 
 namespace furvm {
 
+thing_type executor::thing_type_impl(mod_h mod, mod_type type) const {
+    while (type.type == mod_type::Import) {
+        auto imprt = std::move(type.value.imprt);
+        mod        = m_context->at(imprt.modId);
+        type       = *mod->type_at(imprt.typeId);
+    }
+    switch (static_cast<enum thing_type::type>(type.type)) {
+    case thing_type::S8:
+    case thing_type::S16:
+    case thing_type::S32:
+    case thing_type::S64:
+    case thing_type::U8:
+    case thing_type::U16:
+    case thing_type::U32:
+    case thing_type::U64: return { static_cast<enum thing_type::type>(type.type) };
+    case thing_type::Array: {
+        return { static_cast<enum thing_type::type>(type.type),
+            { thing_type(mod, *mod->type_at(type.value.array.typeId)), type.value.array.size } };
+    }
+    default: throw std::runtime_error("invalid thing type");
+    }
+}
+
+thing_type* executor::thing_type(const mod_h& mod, const mod_type& type) const {
+    struct thing_type thingType = thing_type_impl(mod, type);
+    return m_context->thing_type_store().insert(thingType);
+}
+
 void executor::push_frame(const mod_h& mod, function function) {
     mod_h modInst = mod;
     while (function.type() == function_t::Import) {
@@ -26,7 +54,7 @@ void executor::push_frame(const mod_h& mod, function function) {
     args.reserve(signature.params.size());
     for (const auto& param : signature.params) {
         auto arg = pop_thing();
-        if (arg->type().type != param) throw std::runtime_error("function argument type mismatch");
+        if (arg->type() != *thing_type(mod, *param)) throw std::runtime_error("function argument type mismatch");
         args.push_back(std::move(arg));
     }
 
@@ -87,10 +115,6 @@ thing_h executor::load_thing(variable_t variable) const {
     return frame.variables[variable];
 }
 
-static type_ref get_type_ref(const mod_h& mod, type_id id) {
-    return { mod, mod->type_at(id) };
-}
-
 void executor::step() {
     if ((m_flags & executor_flags::Suspended) == executor_flags::Suspended) return;
 
@@ -100,25 +124,25 @@ void executor::step() {
     switch (instr) {
     case instruction_t::NoOperation: break;
     case instruction_t::PushB2I: {
-        push_thing({ get_type_ref(m_context->at("core"), 2), m_context, m_context->thing_alloc() })->get<int_t>() =
+        push_thing({ (struct thing_type){ thing_type::S32 }, m_context->thing_alloc() })->get<int>() =
             frame.mod->byte(frame.position++);
     } break;
     case instruction_t::Array: {
-        type_id typeId  = static_cast<type_id>(frame.mod->byte(frame.position)) |
-                          (static_cast<type_id>(frame.mod->byte(frame.position + 1)) << 8) |
-                          (static_cast<type_id>(frame.mod->byte(frame.position + 2)) << 16) |
-                          (static_cast<type_id>(frame.mod->byte(frame.position + 3)) << 24);
+        mod_type_id typeId = static_cast<mod_type_id>(frame.mod->byte(frame.position)) |
+                             (static_cast<mod_type_id>(frame.mod->byte(frame.position + 1)) << 8) |
+                             (static_cast<mod_type_id>(frame.mod->byte(frame.position + 2)) << 16) |
+                             (static_cast<mod_type_id>(frame.mod->byte(frame.position + 3)) << 24);
         frame.position    += 4;
 
-        auto type = furvm::thing<>::resolve_type(get_type_ref(frame.mod, typeId), m_context);
-        if (*type.type == nullptr || type->t != type_t::Array || *type->array.type == nullptr)
+        const auto& type = *thing_type(frame.mod, *frame.mod->type_at(typeId));
+        if (type.type != thing_type::Array || type.value.array.type == nullptr || type.value.array.type == &type)
             throw std::runtime_error("invalid array type");
 
-        auto array = push_thing({ type, m_context, m_context->thing_alloc() });
+        auto array = push_thing({ type, m_context->thing_alloc() });
 
-        if (type->array.size == 0) {
+        if (type.value.array.size == 0) {
             auto         sizeThing = pop_thing();
-            long_t size      = sizeThing->integer();
+            std::int64_t size      = sizeThing->integer();
             array->resize(size);
         }
 
@@ -198,28 +222,38 @@ void executor::step() {
         push_thing(lhs->greater_equals(*rhs));
     } break;
     case instruction_t::Pointerof: {
-        auto thing = pop_thing();
-        auto ptr   = push_thing({ get_type_ref(m_context->at("core"), 4), m_context, m_context->thing_alloc() });
-        switch (furvm::thing<>::resolve_type(thing->type(), m_context)->t) {
-        case type_t::Primitive: ptr->get<std::uintptr_t>() = reinterpret_cast<std::uintptr_t>(thing->raw()); break;
-        case type_t::Array:
-            ptr->get<std::uintptr_t>() = reinterpret_cast<std::uintptr_t>(thing->get<array_t>().data);
-            break;
-        case type_t::Import:
-        default: throw std::runtime_error("unreachable");
-        }
+        // auto thing = pop_thing();
+        // auto ptr   = push_thing(
+        //{ (struct thing_type){ thing_type::Primitive, { sizeof(std::uintptr_t) } }, m_context->thing_alloc() });
+        // switch (thing->type().type) {
+        // case thing_type::Primitive: ptr->get<std::uintptr_t>() = reinterpret_cast<std::uintptr_t>(thing->raw());
+        // break; case thing_type::Array: ptr->get<std::uintptr_t>() = reinterpret_cast<std::uintptr_t>(
+        // thing->type().value.array.size == 0 ? thing->get<furvm::thing<>::array>().dynamic.data
+        //: thing->get<furvm::thing<>::array>().flat);
+        // break;
+        // case thing_type::Count: throw std::runtime_error("unreachable");
+        // }
+        throw std::runtime_error("unimplemented"); // TODO: Implement
     } break;
     case instruction_t::Sizeof: {
         auto thing = pop_thing();
-        auto size  = push_thing({ get_type_ref(m_context->at("core"), 3), m_context, m_context->thing_alloc() });
-        auto type  = furvm::thing<>::resolve_type(thing->type(), m_context);
-        switch (type->t) {
-        case type_t::Primitive: size->get<long_t>() = static_cast<long_t>(type->primitive); break;
-        case type_t::Array:
-            size->get<long_t>() =
-                (type->array.size == 0) ? thing->get<array_t>().dynamic.size : static_cast<long_t>(type->array.size);
+        auto size  = push_thing({ (struct thing_type){ thing_type::U64 }, m_context->thing_alloc() });
+        switch (thing->type().type) {
+        case thing_type::S8:
+        case thing_type::S16:
+        case thing_type::S32:
+        case thing_type::S64:
+        case thing_type::U8:
+        case thing_type::U16:
+        case thing_type::U32:
+        case thing_type::U64:
+            size->get<thing_type::u64>() = static_cast<thing_type::u64>(thing_type::primitive_size(thing->type().type));
+            break;
+        case thing_type::Array:
+            size->get<thing_type::u64>() = static_cast<thing_type::u64>(
+                (thing->type().value.array.size == 0) ? thing->get<furvm::thing<>::array>().dynamic.size
+                                                      : thing->type().value.array.size);
             break;
-        case type_t::Import:
         default: throw std::runtime_error("unreachable");
         }
     } break;
@@ -247,7 +281,7 @@ void executor::step() {
     case instruction_t::JumpNotZero: {
         byte offset = frame.mod->byte(frame.position++);
         auto cond   = pop_thing();
-        if (cond->get<int_t>() != 0) frame.position += (std::int8_t)offset;
+        if (cond->integer() != 0) frame.position += (std::int8_t)offset;
     } break;
     case instruction_t::Return: {
         pop_frame();

furvm/src/function.cpp

@@ -98,4 +98,12 @@ function& function::operator=(const function& other) {
     return *this;
 }
 
+namespace detail {
+
+std::size_t function_sig_hash::operator()(const function_sig& signature) const {
+    return furlang::utility::vector_hash<mod_type_h, detail::handle_hash<mod_type_h>>{}(signature.params);
+}
+
+} // namespace detail
+
 } // namespace furvm

furvm/src/main.cpp

@@ -11,19 +11,26 @@
 #include <sstream>
 
 static void print_thing(const furvm::thing<furvm::thing_allocator>& thing) {
-    switch (thing.type()->t) {
-    case furvm::type_t::Primitive: {
-        std::cout << thing.integer();
-    } break;
-    case furvm::type_t::Array: {
+    using namespace furvm;
+
+    switch (thing.type().type) {
+    case thing_type::S8: std::cout << thing.cast_to<thing_type::s16>(); break;
+    case thing_type::S16: std::cout << thing.get<thing_type::s16>(); break;
+    case thing_type::S32: std::cout << thing.get<thing_type::s32>(); break;
+    case thing_type::S64: std::cout << thing.get<thing_type::s64>(); break;
+    case thing_type::U8: std::cout << thing.get<thing_type::u8>(); break;
+    case thing_type::U16: std::cout << thing.get<thing_type::u16>(); break;
+    case thing_type::U32: std::cout << thing.get<thing_type::u32>(); break;
+    case thing_type::U64: std::cout << thing.get<thing_type::u64>(); break;
+    case furvm::thing_type::Array:
         std::cout << "{ ";
-        for (furvm::long_t i = 0; i < thing.size(); ++i) {
+        for (thing_type::u64 i = 0; i < thing.size(); ++i) {
             if (i > 0) std::cout << ", ";
             print_thing(thing.at(i));
         }
-        std::cout << " }\n";
-    } break;
-    default: std::cerr << "{Something went wrong}";
+        std::cout << " }";
+        break;
+    default: std::cerr << "{Type not recognized}";
     }
 }
 
@@ -47,7 +54,7 @@ int main(int argc, char** argv) {
 #else
     static const furvm::byte s_bytecode[] = {
         static_cast<furvm::byte>(furvm::instruction_t::Array),
-        0,
+        1,
         0,
         0,
         0,
@@ -58,12 +65,16 @@ int main(int argc, char** argv) {
         static_cast<furvm::byte>(furvm::instruction_t::Return),
     };
 
-    furvm::mod_h  mod      = context->emplace("main", s_bytecode, s_bytecode + sizeof(s_bytecode));
-    furvm::type_h intType  = mod->emplace_type(std::make_shared<furvm::type>(context->at("core")->type_at(2), 10));
+    auto mod       = context->emplace("main", s_bytecode, s_bytecode + sizeof(s_bytecode));
+    auto charType  = mod->emplace_type(furvm::mod_type::S8);
+    auto arrayType = mod->emplace_type(charType.id(), 10);
     auto mainFunc  = mod->emplace_function("main", furvm::function_sig{}, 0);
-    mod->emplace_function(furvm::function_sig{ { intType } }, "print").dispatch();
+    mod->emplace_function(furvm::function_sig{ { arrayType } }, "print").dispatch();
 #endif
-    mod->set_native_function("print", [](furvm::executor& executor) { print_thing(*executor.load_thing(0)); });
+    mod->set_native_function("print", [](furvm::executor& executor) {
+        print_thing(*executor.load_thing(0));
+        std::cout << '\n';
+    });
 
     furvm::executor_h executor = context->emplace_executor(context);
     executor->push_frame(mod, *mainFunc);

furvm/src/module.cpp

@@ -3,12 +3,10 @@
 #include "furvm/detail/serialization.hpp"
 #include "furvm/function.hpp"
 #include "furvm/fwd.hpp"
-#include "furvm/type.hpp"
 
 #include <cstdint>
 #include <cstring>
 #include <ios>
-#include <memory>
 #include <stdexcept>
 #include <utility>
 
@@ -18,25 +16,33 @@ std::ostream& mod::serialize(std::ostream& os) const {
     os.write(MAGIC, sizeof(MAGIC));
     detail::serialize(os, std::uint32_t(0)); // version
 
-    type_id typeCount = type_id(m_types.cend() - m_types.cbegin());
+    mod_type_id typeCount = mod_type_id(m_types.cend() - m_types.cbegin());
     detail::serialize(os, typeCount);
-    for (type_id id = 0; id < typeCount; ++id) {
+    for (mod_type_id id = 0; id < typeCount; ++id) {
         if (!m_types.contains(id)) {
             detail::serialize(os, std::uint8_t(0xFF)); // null type
             continue;
         }
 
         auto type = *m_types.at(id);
-        switch (type->t) {
-        case type_t::Primitive: detail::serialize(os, type->primitive); break;
-        case type_t::Array: {
-            detail::serialize(os, type->array.size);
-            detail::serialize(os, type->array.type.id());
+        switch (type.type) {
+        case mod_type::S8:
+        case mod_type::S16:
+        case mod_type::S32:
+        case mod_type::S64:
+        case mod_type::U8:
+        case mod_type::U16:
+        case mod_type::U32:
+        case mod_type::U64: break;
+        case mod_type::Array: {
+            detail::serialize(os, type.value.array.typeId);
+            detail::serialize(os, type.value.array.size);
         } break;
-        case type_t::Import: {
-            detail::serialize(os, type->imp.mod);
-            detail::serialize(os, type->imp.type);
+        case mod_type::Import: {
+            detail::serialize(os, type.value.imprt.modId);
+            detail::serialize(os, type.value.imprt.typeId);
         } break;
+        case mod_type::Count: throw std::runtime_error("unreachable");
         }
     }
 
@@ -93,32 +99,35 @@ mod mod::load(std::istream& is) {
 
     mod mod;
 
-    type_id typeCount = 0;
+    mod_type_id typeCount = 0;
     detail::load(is, typeCount);
-    for (type_id id = 0; id < typeCount; ++id) {
+    for (mod_type_id id = 0; id < typeCount; ++id) {
         std::uint8_t type = 0;
         detail::load(is, type);
         if (type == 0xFF) continue;
 
-        switch ((type_t)type) {
-        case type_t::Primitive: {
-            primitive_type primitive = 0;
-            detail::load(is, primitive);
-            mod.emplace_type(id, std::make_shared<class type>(primitive)).dispatch();
-        } break;
-        case type_t::Array: {
+        switch ((enum mod_type::type)type) {
+        case mod_type::S8:
+        case mod_type::S16:
+        case mod_type::S32:
+        case mod_type::S64:
+        case mod_type::U8:
+        case mod_type::U16:
+        case mod_type::U32:
+        case mod_type::U64: break;
+        case mod_type::Array: {
+            mod_type_id typeId = 0;
+            detail::load(is, typeId);
             std::size_t size = 0;
             detail::load(is, size);
-            type_id typeId = 0;
-            detail::load(is, typeId);
-            mod.emplace_type(id, std::make_shared<class type>(mod.type_at(typeId), size)).dispatch();
+            mod.emplace_type(id, typeId, size).dispatch();
         } break;
-        case type_t::Import: {
+        case mod_type::Import: {
             std::string modName;
             detail::load(is, modName);
-            type_id typeId = 0;
+            mod_type_id typeId = 0;
             detail::load(is, typeId);
-            mod.emplace_type(id, std::make_shared<class type>(import_type{ std::move(modName), typeId })).dispatch();
+            mod.emplace_type(id, std::move(modName), typeId).dispatch();
         } break;
         default: throw std::runtime_error("unknown type type");
         }