Sequence equality

compiler+runtime/CMakeLists.txt

@@ -449,11 +449,18 @@ if(jank_tests)
     test/cpp/jank/read/lex.cpp
     test/cpp/jank/read/parse.cpp
     test/cpp/jank/analyze/box.cpp
+    test/cpp/jank/runtime/behavior/callable.cpp
+    test/cpp/jank/runtime/core.cpp
+    test/cpp/jank/runtime/core/seq.cpp
     test/cpp/jank/runtime/detail/native_persistent_list.cpp
     test/cpp/jank/runtime/obj/persistent_string.cpp
     test/cpp/jank/runtime/obj/ratio.cpp
+    test/cpp/jank/runtime/obj/persistent_list.cpp
     test/cpp/jank/runtime/obj/persistent_string.cpp
     test/cpp/jank/runtime/obj/persistent_vector.cpp
+    test/cpp/jank/runtime/obj/range.cpp
+    test/cpp/jank/runtime/obj/integer_range.cpp
+    test/cpp/jank/runtime/obj/repeat.cpp
     test/cpp/jank/jit/processor.cpp
   )
   add_executable(jank::test_exe ALIAS jank_test_exe)

compiler+runtime/include/cpp/jank/runtime/obj/integer_range.hpp

@@ -19,6 +19,7 @@ namespace jank::runtime::obj
 
     using bounds_check_t = native_bool (*)(integer_ptr, integer_ptr);
 
+    /* Constructors are only to be used within integer_range.cpp. Prefer integer_range::create. */
     integer_range() = default;
     integer_range(integer_range &&) noexcept = default;
     integer_range(integer_range const &) = default;

compiler+runtime/include/cpp/jank/runtime/obj/range.hpp

@@ -21,6 +21,7 @@ namespace jank::runtime::obj
 
     using bounds_check_t = native_bool (*)(object_ptr, object_ptr);
 
+    /* Constructors are only to be used within range.cpp. Prefer range::create. */
     range() = default;
     range(range &&) noexcept = default;
     range(range const &) = default;

compiler+runtime/include/cpp/jank/runtime/obj/symbol.hpp

@@ -98,7 +98,7 @@ namespace std
       }
       else if(!rhs)
       {
-        return !lhs;
+        return false;
       }
       return lhs->equal(*rhs);
     }

compiler+runtime/include/cpp/jank/runtime/var.hpp

@@ -159,7 +159,7 @@ namespace std
       }
       else if(!rhs)
       {
-        return !lhs;
+        return false;
       }
       return lhs->equal(*rhs);
     }

compiler+runtime/src/cpp/clojure/core_native.cpp

@@ -578,7 +578,8 @@ jank_object_ptr jank_load_clojure_core_native()
         return obj::boolean::false_const();
       }
 
-      for(auto it(fresh_seq(rest)); it != nullptr; it = next_in_place(it))
+      for(auto it(fresh_seq(rest)); it != nullptr && it != obj::nil::nil_const();
+          it = next_in_place(it))
       {
         if(!is_equiv(l, first(it)))
         {
@@ -798,8 +799,10 @@ jank_object_ptr jank_load_clojure_core_native()
   {
     auto const fn(
       make_box<obj::jit_function>(behavior::callable::build_arity_flags(2, false, false)));
-    fn->arity_1 = [](object * const val) -> object * { return repeat(val); };
-    fn->arity_2 = [](object * const n, object * const val) -> object * { return repeat(n, val); };
+    fn->arity_1 = [](object * const val) -> object * { return obj::repeat::create(val); };
+    fn->arity_2 = [](object * const n, object * const val) -> object * {
+      return obj::repeat::create(n, val);
+    };
     intern_fn_obj("repeat", fn);
   }
 

compiler+runtime/src/cpp/jank/read/parse.cpp

@@ -783,7 +783,7 @@ namespace jank::read::parse
     auto const jank_keyword(__rt_ctx->intern_keyword("", "jank").expect_ok());
     auto const default_keyword(__rt_ctx->intern_keyword("", "default").expect_ok());
 
-    for(auto it(list->fresh_seq()); it != nullptr;)
+    for(auto it(list->fresh_seq()); it != nullptr; it = next_in_place(next_in_place(it)))
     {
       auto const kw(it->first());
       /* We take the first match, checking for :jank first. If there are duplicates, it doesn't
@@ -829,8 +829,6 @@ namespace jank::read::parse
           return object_source_info{ next_in_place(it)->first(), start_token, list_end };
         }
       }
-
-      it = next_in_place(next_in_place(it));
     }
 
     return ok(none);

compiler+runtime/src/cpp/jank/runtime/core.cpp

@@ -245,7 +245,7 @@ namespace jank::runtime
     }
     else if(!rhs)
     {
-      return !lhs;
+      return false;
     }
 
     return visit_object([&](auto const typed_lhs) { return typed_lhs->equal(*rhs); }, lhs);

compiler+runtime/src/cpp/jank/runtime/core/seq.cpp

@@ -478,21 +478,13 @@ namespace jank::runtime
         {
           return make_box<obj::persistent_list>(std::in_place, o);
         }
-        else if constexpr(behavior::conjable_in_place<T>)
-        {
-          return typed_s->conj_in_place(o);
-        }
         else if constexpr(behavior::conjable<T>)
         {
           return typed_s->conj(o);
         }
-        else if constexpr(behavior::seqable<T>)
-        {
-          return typed_s->seq()->conj(o);
-        }
         else
         {
-          throw std::runtime_error{ fmt::format("not seqable: {}", typed_s->to_string()) };
+          throw std::runtime_error{ fmt::format("not conjable: {}", typed_s->to_string()) };
         }
       },
       s);
@@ -521,11 +513,7 @@ namespace jank::runtime
       [&](auto const typed_m) -> object_ptr {
         using T = typename decltype(typed_m)::value_type;
 
-        if constexpr(behavior::associatively_writable_in_place<T>)
-        {
-          return typed_m->assoc_in_place(k, v);
-        }
-        else if constexpr(behavior::associatively_writable<T>)
+        if constexpr(behavior::associatively_writable<T>)
         {
           return typed_m->assoc(k, v);
         }
@@ -544,11 +532,7 @@ namespace jank::runtime
       [&](auto const typed_m) -> object_ptr {
         using T = typename decltype(typed_m)::value_type;
 
-        if constexpr(behavior::associatively_writable_in_place<T>)
-        {
-          return typed_m->dissoc_in_place(k);
-        }
-        else if constexpr(behavior::associatively_writable<T>)
+        if constexpr(behavior::associatively_writable<T>)
         {
           return typed_m->dissoc(k);
         }
@@ -1025,23 +1009,10 @@ namespace jank::runtime
         return visit_seqable(
           [](auto const typed_r, auto const typed_l) -> native_bool {
             auto r_it(typed_r->fresh_seq());
-            auto l_it(typed_l->fresh_seq());
-            if(!r_it)
+            for(auto l_it(typed_l->fresh_seq()); l_it != nullptr;
+                l_it = l_it->next_in_place(), r_it = r_it->next_in_place())
             {
-              return l_it == nullptr;
-            }
-            if(!l_it)
-            {
-              return r_it == nullptr;
-            }
-
-            for(; l_it != nullptr; l_it = l_it->next_in_place(), r_it = r_it->next_in_place())
-            {
-              if(!r_it)
-              {
-                return false;
-              }
-              if(!runtime::equal(l_it->first(), r_it->first()))
+              if(!r_it || !runtime::equal(l_it->first(), r_it->first()))
               {
                 return false;
               }
@@ -1178,12 +1149,12 @@ namespace jank::runtime
 
   object_ptr repeat(object_ptr const val)
   {
-    return make_box<obj::repeat>(val);
+    return obj::repeat::create(val);
   }
 
   object_ptr repeat(object_ptr const n, object_ptr const val)
   {
-    return make_box<obj::repeat>(n, val);
+    return obj::repeat::create(n, val);
   }
 
   object_ptr sort(object_ptr const coll)

compiler+runtime/src/cpp/jank/runtime/obj/chunked_cons.cpp

@@ -162,12 +162,12 @@ namespace jank::runtime::obj
         for(auto it(fresh_seq()); it != nullptr;
             it = runtime::next_in_place(it), seq = runtime::next_in_place(seq))
         {
-          if(seq == nullptr || !runtime::equal(it, seq->first()))
+          if(seq == nullptr || !runtime::equal(it->first(), seq->first()))
           {
             return false;
           }
         }
-        return true;
+        return seq == nullptr;
       },
       []() { return false; },
       &o);

compiler+runtime/src/cpp/jank/runtime/obj/cons.cpp

@@ -77,12 +77,12 @@ namespace jank::runtime::obj
         for(auto it(fresh_seq()); it != nullptr;
             it = runtime::next_in_place(it), seq = runtime::next_in_place(seq))
         {
-          if(seq == nullptr || !runtime::equal(it, seq->first()))
+          if(seq == nullptr || !runtime::equal(it->first(), seq->first()))
           {
             return false;
           }
         }
-        return true;
+        return seq == nullptr;
       },
       []() { return false; },
       &o);

compiler+runtime/src/cpp/jank/runtime/obj/detail/base_persistent_map_sequence.cpp

@@ -23,12 +23,12 @@ namespace jank::runtime::obj::detail
         for(auto it(fresh_seq()); it != nullptr;
             it = it->next_in_place(), seq = seq->next_in_place())
         {
-          if(seq == nullptr || !runtime::equal(it, seq->first()))
+          if(seq == nullptr || !runtime::equal(it->first(), seq->first()))
           {
             return false;
           }
         }
-        return true;
+        return seq == nullptr;
       },
       []() { return false; },
       &o);

compiler+runtime/src/cpp/jank/runtime/obj/detail/iterator_sequence.cpp

@@ -39,7 +39,7 @@ namespace jank::runtime::obj::detail
             return false;
           }
         }
-        return true;
+        return seq == nullptr;
       },
       []() { return false; },
       &o);

compiler+runtime/src/cpp/jank/runtime/obj/integer_range.cpp

@@ -80,7 +80,7 @@ namespace jank::runtime::obj
     }
     else if(is_zero(step))
     {
-      return make_box<repeat>(make_box<integer>(start));
+      return repeat::create(make_box<integer>(start));
     }
     return make_box<integer_range>(start,
                                    end,
@@ -137,12 +137,12 @@ namespace jank::runtime::obj
         for(auto it(fresh_seq()); it != nullptr;
             it = it->next_in_place(), seq = seq->next_in_place())
         {
-          if(seq == nullptr || !runtime::equal(it, seq->first()))
+          if(seq == nullptr || !runtime::equal(it->first(), seq->first()))
           {
             return false;
           }
         }
-        return true;
+        return seq == nullptr;
       },
       []() { return false; },
       &o);

compiler+runtime/src/cpp/jank/runtime/obj/iterator.cpp

@@ -64,12 +64,12 @@ namespace jank::runtime::obj
         for(auto it(fresh_seq()); it != nullptr;
             it = runtime::next_in_place(it), seq = runtime::next_in_place(seq))
         {
-          if(seq == nullptr || !runtime::equal(it, seq->first()))
+          if(seq == nullptr || !runtime::equal(it->first(), seq->first()))
           {
             return false;
           }
         }
-        return true;
+        return seq == nullptr;
       },
       []() { return false; },
       &o);

compiler+runtime/src/cpp/jank/runtime/obj/native_array_sequence.cpp

@@ -23,7 +23,7 @@ namespace jank::runtime::obj
     assert(size > 0);
   }
 
-  /* behavior::objectable */
+  /* behavior::object_like */
   native_bool native_array_sequence::equal(object const &o) const
   {
     return runtime::equal(o, arr + index, arr + size);

compiler+runtime/src/cpp/jank/runtime/obj/native_vector_sequence.cpp

@@ -32,7 +32,7 @@ namespace jank::runtime::obj
   {
   }
 
-  /* behavior::objectable */
+  /* behavior::object_like */
   native_bool native_vector_sequence::equal(object const &o) const
   {
     return runtime::equal(o, data.begin(), data.end());

compiler+runtime/src/cpp/jank/runtime/obj/persistent_list.cpp

@@ -86,11 +86,7 @@ namespace jank::runtime::obj
 
   persistent_list_sequence_ptr persistent_list::seq() const
   {
-    if(data.empty())
-    {
-      return nullptr;
-    }
-    return make_box<persistent_list_sequence>(this, data.begin(), data.end(), data.size());
+    return fresh_seq();
   }
 
   persistent_list_sequence_ptr persistent_list::fresh_seq() const

compiler+runtime/src/cpp/jank/runtime/obj/persistent_string.cpp

@@ -156,11 +156,7 @@ namespace jank::runtime::obj
 
   persistent_string_sequence_ptr persistent_string::seq() const
   {
-    if(data.empty())
-    {
-      return nullptr;
-    }
-    return make_box<persistent_string_sequence>(const_cast<persistent_string *>(this));
+    return fresh_seq();
   }
 
   persistent_string_sequence_ptr persistent_string::fresh_seq() const

compiler+runtime/src/cpp/jank/runtime/obj/persistent_string_sequence.cpp

@@ -19,7 +19,7 @@ namespace jank::runtime::obj
     assert(!s->data.empty() && i < s->data.size());
   }
 
-  /* behavior::objectable */
+  /* behavior::object_like */
   native_bool persistent_string_sequence::equal(object const &o) const
   {
     return runtime::equal(o, str->data.begin() + index, str->data.end());

compiler+runtime/src/cpp/jank/runtime/obj/persistent_vector.cpp

@@ -97,18 +97,12 @@ namespace jank::runtime::obj
           {
             size_t i{};
             auto e(typed_o->fresh_seq());
-            for(; e != nullptr; e = e->next_in_place())
+            for(; e != nullptr && i < data.size(); e = e->next_in_place(), ++i)
             {
               if(!runtime::equal(data[i], e->first()))
               {
                 return false;
               }
-
-              if(++i == data.size())
-              {
-                e = e->next_in_place();
-                break;
-              }
             }
             return e == nullptr && i == data.size();
           }
@@ -184,11 +178,7 @@ namespace jank::runtime::obj
 
   persistent_vector_sequence_ptr persistent_vector::seq() const
   {
-    if(data.empty())
-    {
-      return nullptr;
-    }
-    return make_box<persistent_vector_sequence>(const_cast<persistent_vector *>(this));
+    return fresh_seq();
   }
 
   persistent_vector_sequence_ptr persistent_vector::fresh_seq() const

compiler+runtime/src/cpp/jank/runtime/obj/persistent_vector_sequence.cpp

@@ -20,7 +20,7 @@ namespace jank::runtime::obj
     assert(0 < v->data.size() - index);
   }
 
-  /* behavior::objectable */
+  /* behavior::object_like */
   native_bool persistent_vector_sequence::equal(object const &o) const
   {
     return runtime::equal(