adds conj!, assoc! and dissoc! for transients

jank-lang · Mar 16, 2024 · 78ad135 · 78ad135
1 parent 79e9275
commit 78ad135
Show file tree

Hide file tree

Showing 5 changed files with 93 additions and 2 deletions.
diff --git a/include/cpp/jank/prelude.hpp b/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>
diff --git a/include/cpp/jank/runtime/behavior/associatively_writable.hpp b/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>;
   };
 }
diff --git a/include/cpp/jank/runtime/obj/transient_hash_map.hpp b/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);

diff --git a/src/cpp/jank/runtime/obj/transient_hash_map.cpp b/src/cpp/jank/runtime/obj/transient_hash_map.cpp
@@ -97,6 +97,14 @@ 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();

diff --git a/src/jank/clojure/core.jank b/src/jank/clojure/core.jank
@@ -431,6 +431,87 @@
                  #{ 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)))))
+
 ; Functions.
 
 (defn- spread [arglist]