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

include/cpp/jank/prelude.hpp

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

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

@@ -16,5 +16,9 @@ namespace jank::runtime::behavior
     {
       t->assoc_in_place(object_ptr{}, object_ptr{})
     } -> std::convertible_to<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

@@ -47,6 +47,8 @@ namespace jank::runtime
     object_ptr get_entry(object_ptr const idx) const;
     native_bool contains(object_ptr const elem) const;
 
+    native_box<static_object> pop_in_place();
+
     void assert_active() const;
 
     object base{ object_type::transient_vector };

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

@@ -97,6 +97,13 @@ namespace jank::runtime
     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();

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

@@ -154,6 +154,18 @@ namespace jank::runtime
     }
   }
 
+  obj::transient_vector_ptr obj::transient_vector::pop_in_place()
+  {
+    assert_active();
+    if(data.empty())
+    {
+      throw std::runtime_error{ "Can't pop empty vector" };
+    }
+
+    data.take(data.size() - 1);
+    return this;
+  }
+
   void obj::transient_vector::assert_active() const
   {
     if(!active)

src/jank/clojure/core.jank

@@ -400,9 +400,9 @@
                    if constexpr(behavior::transientable<T>)
                    { return typed_o->to_transient(); }
                    else
-                   { throw #{ (ex-info :not-transientable {:o o}) }#; }
+                   { throw ~{ (ex-info :not-transientable {:o o}) }; }
                  },
-                 #{ o }#
+                 ~{ o }
                );"))
 
 ; Returns a new, persistent version of the transient collection, in
@@ -418,11 +418,91 @@
                    if constexpr(behavior::persistentable<T>)
                    { return typed_o->to_persistent(); }
                    else
-                   { throw #{ (ex-info :not-persistentable {:o o}) }#; }
+                   { throw ~{ (ex-info :not-persistentable {:o o}) }; }
                  },
-                 #{ o }#
+                 ~{ o }
                );"))
 
+(defn conj!
+  ([]
+   (transient []))
+  ([coll]
+   coll)
+  ([coll x]
+   (native/raw "__value = visit_object
+                (
+                  [=](auto const typed_coll, auto const head) -> object_ptr
+                  {
+                    using T = typename decltype(typed_coll)::value_type;
+
+                    if constexpr(behavior::consable_in_place<T>)
+                    { return typed_coll->cons_in_place(head); }
+                    else
+                    { throw ~{ (ex-info :not-persistentable {:o coll}) }; }
+                   },
+                   ~{ coll },
+                   ~{ x }
+                 );
+               ")))
+
+(defn assoc!
+  ([coll k v]
+   (native/raw "__value = visit_object
+                (
+                  [=](auto const typed_coll, auto const key, auto const val) -> object_ptr
+                  {
+                    using T = typename decltype(typed_coll)::value_type;
+
+                    if constexpr(behavior::associatively_writable_in_place<T>)
+                    { return typed_coll->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))))
+
+(defn dissoc!
+  ([coll k]
+   (native/raw "__value = visit_object
+                (
+                  [=](auto const typed_coll, auto const key) -> object_ptr
+                  {
+                    using T = typename decltype(typed_coll)::value_type;
+
+                    if constexpr(behavior::associatively_writable_in_place<T>)
+                    { return typed_coll->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))))
+
+(defn pop!
+  ([coll]
+   (native/raw "if( ~{ coll }->type == object_type::transient_vector )
+                {
+                  auto transient_coll = expect_object<obj::transient_vector>(~{ coll });
+                  __value = transient_coll->pop_in_place();
+                }
+                else
+                { throw ~{ (ex-info :not-transient-vector {:o coll}) }; }
+               ")))
+
 ; Functions.
 
 (defn- spread [arglist]