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

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_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

@@ -512,6 +512,27 @@
           (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]