jule: reimplement traits

julelang · Mar 27, 2024 · cd624f1 · cd624f1
1 parent 675385a
commit cd624f1
Show file tree

Hide file tree

Showing 18 changed files with 848 additions and 370 deletions.
diff --git a/api/any.hpp b/api/any.hpp
@@ -13,18 +13,12 @@
 #include <ostream>
 
 #include "str.hpp"
-#include "builtin.hpp"
-#include "ptr.hpp"
 
 namespace jule
 {
-
-    // Built-in any type.
-    class Any;
-
     class Any
     {
-    private:
+    public:
         template <typename T>
         struct DynamicType
         {
@@ -135,7 +129,7 @@ namespace jule
         template <typename T>
         void __assign(const T &expr) noexcept
         {
-            T *alloc = new (std::nothrow) T;
+            auto alloc = new (std::nothrow) T;
             if (!alloc)
                 jule::panic(__JULE_ERROR__MEMORY_ALLOCATION_FAILED
                             "\nruntime: memory allocation failed for heap data of type any");
@@ -149,7 +143,6 @@ namespace jule
         {
             if (this->data)
                 this->type->dealloc(this->data);
-
             this->type = nullptr;
             this->data = nullptr;
         }
@@ -167,7 +160,7 @@ namespace jule
         }
 
         template <typename T>
-        Any& operator=(const T &expr) noexcept
+        Any &operator=(const T &expr) noexcept
         {
             jule::Any::Type *type = jule::Any::new_type<T>();
             if (this->type != nullptr && this->type == type)
@@ -181,7 +174,7 @@ namespace jule
             return *this;
         }
 
-        Any& operator=(const jule::Any &src) noexcept
+        Any &operator=(const jule::Any &src) noexcept
         {
             // Assignment to itself.
             if (this->data != nullptr && this->data == src.data)
@@ -192,7 +185,7 @@ namespace jule
             return *this;
         }
 
-        inline Any& operator=(const std::nullptr_t) noexcept
+        inline Any &operator=(const std::nullptr_t) noexcept
         {
             this->dealloc();
             return *this;

diff --git a/api/derive/clone.hpp b/api/derive/clone.hpp
@@ -37,6 +37,8 @@ namespace jule
     jule::Ptr<T> clone(const jule::Ptr<T> &r);
     template <typename T>
     jule::Trait<T> clone(const jule::Trait<T> &t);
+    template <typename Mask>
+    jule::Trait2<Mask> clone(const jule::Trait2<Mask> &t);
     template <typename T>
     jule::Fn<T> clone(const jule::Fn<T> &fn) noexcept;
     template <typename T>
@@ -91,8 +93,7 @@ namespace jule
     {
         if (r == nullptr)
             return r;
-
-        return jule::Ptr<T>::make(jule::clone(r.operator T()));
+        return jule::Ptr<T>::make(jule::clone(*r));
     }
 
     template <typename T>
@@ -103,6 +104,17 @@ namespace jule
         return t;
     }
 
+    template <typename Mask>
+    jule::Trait2<Mask> clone(const jule::Trait2<Mask> &t) {
+        if (t == nullptr)
+            return t;
+        jule::Trait2<Mask> clone;
+        clone.type = t.type;
+        clone.type_offset = t.type_offset;
+        clone.data = jule::Ptr<jule::Uintptr>::make(t.type->clone(t.data.alloc));
+        return clone;
+    }
+
     template <typename T>
     jule::Fn<T> clone(const jule::Fn<T> &fn) noexcept
     {

diff --git a/api/ptr.hpp b/api/ptr.hpp
@@ -224,6 +224,19 @@ namespace jule
             return *this->alloc;
         }
 
+        template <typename T2>
+        jule::Ptr<T2> as(void) const noexcept
+        {
+            jule::Ptr<T2> ptr;
+            ptr.ref = this->ref;
+#ifndef __JULE_DISABLE__REFERENCE_COUNTING
+            if (this->ref)
+                this->add_ref();
+#endif
+            ptr.alloc = reinterpret_cast<T2 *>(this->alloc);
+            return ptr;
+        }
+
         inline T *operator->(void) const noexcept
         {
             return this->ptr(
@@ -272,7 +285,7 @@ namespace jule
             }
         }
 
-        Ptr& operator=(const jule::Ptr<T> &src) noexcept
+        Ptr &operator=(const jule::Ptr<T> &src) noexcept
         {
             // Assignment to itself.
             if (this->alloc != nullptr && this->alloc == src.alloc)

diff --git a/api/slice.hpp b/api/slice.hpp
@@ -210,8 +210,8 @@ namespace jule
                 *(this->_slice + i) = def;
         }
 
-        using Iterator = Item*;
-        using ConstIterator = const Item*;
+        using Iterator = Item *;
+        using ConstIterator = const Item *;
 
         constexpr Iterator begin(void) noexcept
         {
@@ -323,10 +323,7 @@ namespace jule
             {
                 jule::Slice<Item> _new;
                 _new.alloc_new(this->_len + 1, (this->_len + 1) << 1);
-                std::move(
-                    this->_slice,
-                    this->_slice + this->_len,
-                    _new._slice);
+                std::move(this->_slice, this->_slice + this->_len, _new._slice);
                 *(_new._slice + this->_len) = item;
 
                 this->operator=(_new);
@@ -441,7 +438,7 @@ namespace jule
                 index);
         }
 
-        Slice& operator=(const jule::Slice<Item> &src) noexcept
+        Slice &operator=(const jule::Slice<Item> &src) noexcept
         {
             // Assignment to itself.
             if (this->data.alloc != nullptr && this->data.alloc == src.data.alloc)
@@ -457,7 +454,7 @@ namespace jule
             return *this;
         }
 
-        inline Slice& operator=(const std::nullptr_t) noexcept
+        inline Slice &operator=(const std::nullptr_t) noexcept
         {
             this->dealloc();
             return *this;