feat(transient): adds conj!, assoc!, dissoc! and pop! for transients

include/cpp/jank/prelude.hpp

@@ -28,3 +28,4 @@
 #include <jank/runtime/behavior/numberable.hpp>
 #include <jank/runtime/behavior/nameable.hpp>
 #include <jank/runtime/behavior/transientable.hpp>
+#include <jank/runtime/behavior/associatively_writable.hpp>

include/cpp/jank/runtime/behavior/associatively_writable.hpp

@@ -14,7 +14,7 @@ namespace jank::runtime::behavior
   template <typename T>
   concept associatively_writable_in_place = requires(T * const t) {
     {
-      t->assoc_in_place(object_ptr{}, object_ptr{})
+      t->assoc_in_place(object_ptr{}, object_ptr{}), t->dissoc_in_place(object_ptr{})
     } -> std::convertible_to<object_ptr>;
   };
 }

include/cpp/jank/runtime/obj/transient_hash_map.hpp

@@ -41,7 +41,8 @@ namespace jank::runtime
     native_bool contains(object_ptr key) const;
 
     /* behavior::associatively_writable_in_place */
-    native_box<static_object> assoc_in_place(object_ptr key, object_ptr val);
+    native_box<static_object> assoc_in_place(object_ptr const key, object_ptr const val);
+    native_box<static_object> dissoc_in_place(object_ptr const key);
 
     /* behavior::consable_in_place */
     native_box<static_object> cons_in_place(object_ptr head);

include/cpp/jank/runtime/obj/transient_vector.hpp

@@ -23,6 +23,8 @@ namespace jank::runtime
       return ret;
     }
 
+    native_box<static_object> pop();
+
     /* behavior::objectable */
     native_bool equal(object const &) const;
     native_persistent_string to_string() const;

src/cpp/jank/runtime/obj/transient_hash_map.cpp

@@ -22,135 +22,142 @@
   native_bool obj::transient_hash_map::equal(object const &o) const
   {
     /* Transient equality, in Clojure, is based solely on identity. */
     return &base == &o;
   }
 
   void obj::transient_hash_map::to_string(fmt::memory_buffer &buff) const
   {
     auto inserter(std::back_inserter(buff));
     fmt::format_to(inserter, "{}@{}", magic_enum::enum_name(base.type), fmt::ptr(&base));
   }
 
   native_persistent_string obj::transient_hash_map::to_string() const
   {
     fmt::memory_buffer buff;
     to_string(buff);
     return native_persistent_string{ buff.data(), buff.size() };
   }
 
   native_hash obj::transient_hash_map::to_hash() const
   {
     /* Hash is also based only on identity. Clojure uses default hashCode, which does the same. */
     return static_cast<native_hash>(reinterpret_cast<uintptr_t>(this));
   }
 
   size_t obj::transient_hash_map::count() const
   {
     assert_active();
     return data.size();
   }
 
   object_ptr obj::transient_hash_map::get(object_ptr const key) const
   {
     assert_active();
     auto const res(data.find(key));
     if(res)
     {
       return *res;
     }
     return obj::nil::nil_const();
   }
 
   object_ptr obj::transient_hash_map::get(object_ptr const key, object_ptr const fallback) const
   {
     assert_active();
     auto const res(data.find(key));
     if(res)
     {
       return *res;
     }
     return fallback;
   }
 
   object_ptr obj::transient_hash_map::get_entry(object_ptr const key) const
   {
     assert_active();
     auto const res(data.find(key));
     if(res)
     {
       return make_box<obj::persistent_vector>(key, *res);
     }
     return obj::nil::nil_const();
   }
 
   native_bool obj::transient_hash_map::contains(object_ptr const key) const
   {
     assert_active();
     return data.find(key);
   }
 
   obj::transient_hash_map_ptr
   obj::transient_hash_map::assoc_in_place(object_ptr const key, object_ptr const val)
   {
     assert_active();
     data.set(key, val);
     return this;
   }
 
+  obj::transient_hash_map_ptr obj::transient_hash_map::dissoc_in_place(object_ptr const key)
+  {
+    assert_active();
+    data.erase(key);
+    return this;
+  }
+
   obj::transient_hash_map_ptr obj::transient_hash_map::cons_in_place(object_ptr const head)
   {
     assert_active();
     if(head->type != object_type::persistent_vector)
     {
       throw std::runtime_error{ fmt::format("invalid map entry: {}",
                                             runtime::detail::to_string(head)) };
     }
 
     auto const vec(expect_object<obj::persistent_vector>(head));
     if(vec->count() != 2)
     {
       throw std::runtime_error{ fmt::format("invalid map entry: {}",
                                             runtime::detail::to_string(head)) };
     }
 
     data.set(vec->data[0], vec->data[1]);
     return this;
   }
 
   native_box<obj::transient_hash_map::persistent_type> obj::transient_hash_map::to_persistent()
   {
     assert_active();
     active = false;
     return make_box<obj::persistent_hash_map>(std::move(data));
   }
 
   object_ptr obj::transient_hash_map::call(object_ptr const o) const
   {
     assert_active();
     auto const found(data.find(o));
     if(!found)
     {
       return obj::nil::nil_const();
     }
     return *found;
   }
 
   object_ptr obj::transient_hash_map::call(object_ptr const o, object_ptr const fallback) const
   {
     assert_active();
     auto const found(data.find(o));
     if(!found)
     {
       return fallback;
     }
     return *found;
   }
 
   void obj::transient_hash_map::assert_active() const
   {
     if(!active)
     {
       throw std::runtime_error{ "transient used after it's been made persistent" };
     }
   }
 }

src/cpp/jank/runtime/obj/transient_vector.cpp

@@ -18,147 +18,160 @@
   native_bool obj::transient_vector::equal(object const &o) const
   {
     /* Transient equality, in Clojure, is based solely on identity. */
     return &base == &o;
   }
 
   native_persistent_string obj::transient_vector::to_string() const
   {
     fmt::memory_buffer buff;
     to_string(buff);
     return native_persistent_string{ buff.data(), buff.size() };
   }
 
   void obj::transient_vector::to_string(fmt::memory_buffer &buff) const
   {
     auto inserter(std::back_inserter(buff));
     fmt::format_to(inserter, "{}@{}", magic_enum::enum_name(base.type), fmt::ptr(&base));
   }
 
   native_hash obj::transient_vector::to_hash() const
   {
     /* Hash is also based only on identity. Clojure uses default hashCode, which does the same. */
     return static_cast<native_hash>(reinterpret_cast<uintptr_t>(this));
   }
 
+  obj::transient_vector_ptr obj::transient_vector::pop()
+  {
+    assert_active();
+    if(data.empty())
+    {
+      throw std::runtime_error{ "Can't pop empty vector" };
+    }
+
+    data.take(data.size() - 1);
+
+    return this;
+  }
+
   size_t obj::transient_vector::count() const
   {
     assert_active();
     return data.size();
   }
 
   obj::transient_vector_ptr obj::transient_vector::cons_in_place(object_ptr const head)
   {
     assert_active();
     data.push_back(head);
     return this;
   }
 
   native_box<obj::transient_vector::persistent_type> obj::transient_vector::to_persistent()
   {
     assert_active();
     active = false;
     return make_box<obj::persistent_vector>(data.persistent());
   }
 
   object_ptr obj::transient_vector::call(object_ptr const idx) const
   {
     assert_active();
     if(idx->type == object_type::integer)
     {
       auto const i(expect_object<obj::integer>(idx)->data);
       if(i < 0 || data.size() <= static_cast<size_t>(i))
       {
         throw std::runtime_error{
           fmt::format("Index out of bound; index = {}, count = {}", i, count())
         };
       }
 
       return data[i];
     }
     else
     {
       throw std::runtime_error{ fmt::format("key must be an integer; found {}",
                                             runtime::detail::to_string(idx)) };
     }
   }
 
   object_ptr obj::transient_vector::get(object_ptr const idx) const
   {
     assert_active();
     if(idx->type == object_type::integer)
     {
       auto const i(expect_object<obj::integer>(idx)->data);
       if(i < 0 || data.size() <= static_cast<size_t>(i))
       {
         return obj::nil::nil_const();
       }
 
       return data[i];
     }
     else
     {
       throw std::runtime_error{ fmt::format("key must be an integer; found {}",
                                             runtime::detail::to_string(idx)) };
     }
   }
 
   object_ptr obj::transient_vector::get(object_ptr const idx, object_ptr const fallback) const
   {
     assert_active();
     if(idx->type == object_type::integer)
     {
       auto const i(expect_object<obj::integer>(idx)->data);
       if(i < 0 || data.size() <= static_cast<size_t>(i))
       {
         return fallback;
       }
 
       return data[i];
     }
     else
     {
       throw std::runtime_error{ fmt::format("key must be an integer; found {}",
                                             runtime::detail::to_string(idx)) };
     }
   }
 
   object_ptr obj::transient_vector::get_entry(object_ptr const idx) const
   {
     if(idx->type == object_type::integer)
     {
       auto const i(expect_object<obj::integer>(idx)->data);
       if(i < 0 || data.size() <= static_cast<size_t>(i))
       {
         return obj::nil::nil_const();
       }
       /* TODO: Map entry type? */
       return make_box<obj::persistent_vector>(idx, data[i]);
     }
     else
     {
       throw std::runtime_error{ fmt::format("get_entry on a vector must be an integer; found {}",
                                             runtime::detail::to_string(idx)) };
     }
   }
 
   native_bool obj::transient_vector::contains(object_ptr const elem) const
   {
     if(elem->type == object_type::integer)
     {
       auto const i(expect_object<obj::integer>(elem)->data);
       return i >= 0 && static_cast<size_t>(i) < data.size();
     }
     else
     {
       return false;
     }
   }
 
   void obj::transient_vector::assert_active() const
   {
     if(!active)
     {
       throw std::runtime_error{ "transient used after it's been made persistent" };
     }
   }
 }

src/jank/clojure/core.jank

@@ -431,6 +431,108 @@
                  #{ o }#
                );"))
 
+(def conj!)
+(def conj!
+  (fn* conj!
+    ([]
+     (transient []))
+    ([coll]
+     coll)
+    ([coll x]
+     (native/raw "__value = visit_object
+                  (
+                    [&](auto const typed_t, auto const head) -> object_ptr
+                    {
+                      using T = typename decltype(typed_t)::value_type;
+
+                        if constexpr(behavior::persistentable<T>)
+                        {
+                          return typed_t->cons_in_place(head);
+                        }
+                       else
+                       { throw #{ (ex-info :not-persistentable {:o coll}) }#; }
+                     },
+                     #{ coll }#,
+                     #{ x }#
+                   );
+                 "))))
+
+(def assoc!)
+(def assoc!
+  (fn* assoc!
+    ([coll k v]
+     (native/raw "__value = visit_object
+                  (
+                    [&](auto const typed_t, auto const key, auto const val) -> object_ptr
+                    {
+                      using T = typename decltype(typed_t)::value_type;
+
+                      if constexpr(behavior::associatively_writable_in_place<T>)
+                      {
+                        return typed_t->assoc_in_place(key, val);
+                      }
+                      else
+                      { throw #{ (ex-info :not-associatively_writable_in_place {:o coll}) }#; }
+                    },
+                    #{ coll }#,
+                    #{ k }#,
+                    #{ v }#
+                  );
+                 "))
+    ([coll k v & kvs]
+      (let* [ret (assoc! coll k v)]
+        (if kvs
+          (recur ret (first kvs) (second kvs) (nnext kvs))
+          ret)))))
+
+(def dissoc!)
+(def dissoc!
+  (fn* dissoc!
+    ([coll k]
+     (native/raw "__value = visit_object
+                  (
+                    [&](auto const typed_t, auto const key) -> object_ptr
+                    {
+                      using T = typename decltype(typed_t)::value_type;
+
+                      if constexpr(behavior::associatively_writable_in_place<T>)
+                      {
+                        return typed_t->dissoc_in_place(key);
+                      }
+                      else
+                      { throw #{ (ex-info :not-associatively_writable_in_place {:o coll}) }#; }
+                    },
+                    #{ coll }#,
+                    #{ k }#
+                  );
+                 "))
+    ([coll k & ks]
+      (let* [ret (dissoc! coll k)]
+        (if ks
+          (recur ret (first ks) (next ks))
+          ret)))))
+
+(def pop!)
+(def pop!
+  (fn* pop!
+    ([coll]
+     (native/raw "__value = visit_object
+                  (
+                    [&](auto const typed_t) -> object_ptr
+                    {
+                      using T = typename decltype(typed_t)::value_type;
+
+                      if constexpr(std::same_as<T, obj::transient_vector>)
+                      {
+                        return typed_t->pop();
+                      }
+                      else
+                      { throw #{ (ex-info :not-transient-vector {:o coll}) }#; }
+                    },
+                    #{ coll }#
+                  );
+                 "))))
+
 ; Functions.
 
 (defn- spread [arglist]