sequences: seq_iter_init walks records via prim_seq's kv decomposition

(into {} record) returned {} because seq_iter_init's switch fell
through the default (immediately-done) case for MINO_RECORD.
prim_seq had a record case that built a [k v] cons list in declared
order, but every downstream consumer (into, reduce, transduce,
etc.) talks to seq_iter_init instead of prim_seq directly.

seq_iter_init now calls prim_seq up-front when given a record, then
proceeds as if walking the resulting cons list. (into {} record),
(into [] record), and (reduce conj #{} record) all work as expected.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: leifericf

CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## v0.255.25 — Fix: `seq_iter_init` walks records as kv pairs
+
+`(into {} record)` returned `{}` instead of `{:x 1 :y 2}`. The
+iterator that backs `into`, `reduce`, `transduce`, and most other
+seq aggregates fell through to the default (immediately-done) case
+for `MINO_RECORD`. `prim_seq` itself had a record case that built a
+`[k v]` cons list in declared-field-then-ext order, but the
+iterator didn't route through it.
+
+`seq_iter_init` now routes `MINO_RECORD` through `prim_seq` up-front
+so every downstream consumer walks records as a seq of `[k v]`
+pairs. After this:
+
+```clojure
+(into {} (->Point 1 2))           ; => {:x 1 :y 2}
+(into [] (->Point 1 2))           ; => [[:x 1] [:y 2]]
+(reduce conj #{} (->Point 1 2))   ; => #{[:x 1] [:y 2]}
+```
+
+Regression in `tests/records_test.clj` (`record-seq-is-iterable`).
+
 ## v0.255.24 — Fix: Vector destructuring of lazy / chunked seqs
 
 `(let [[a b c] (range 3)] [a b c])` returned `[nil nil nil]` instead

src/mino.h

@@ -28,7 +28,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 255
-#define MINO_VERSION_PATCH 24
+#define MINO_VERSION_PATCH 25
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".

src/prim/sequences.c

@@ -330,6 +330,18 @@ void seq_iter_init(mino_state_t *S, seq_iter_t *it, const mino_val_t *coll)
         (mino_type_of(coll) == MINO_SORTED_MAP || mino_type_of(coll) == MINO_SORTED_SET)) {
         coll = sorted_seq(S, coll);
     }
+    /* Records: route through prim_seq which builds a cons list of
+     * [k v] pairs in declared-field-then-ext-insertion order. Without
+     * this, seq_iter_done returns true immediately for MINO_RECORD
+     * (default case), so `(into {} record)` returned `{}` and any
+     * other seq-based aggregate over a record came back empty. */
+    if (coll != NULL && mino_type_of(coll) == MINO_RECORD) {
+        mino_val_t *args = mino_cons(S, (mino_val_t *)coll, mino_nil(S));
+        coll = prim_seq(S, args, NULL);
+        if (coll != NULL && mino_type_of(coll) == MINO_LAZY) {
+            coll = lazy_force(S, (mino_val_t *)coll);
+        }
+    }
     it->coll  = coll;
     it->idx   = 0;
     it->cons_p = (coll != NULL && mino_type_of(coll) == MINO_CONS) ? coll : NULL;

tests/records_test.clj

@@ -109,6 +109,23 @@
     (is (satisfies? IGreet g))
     (is (instance? Greeter g))))
 
+(deftest record-seq-is-iterable
+  ;; Regression: seq_iter_init didn't handle MINO_RECORD, so any seq-
+  ;; iterator-based aggregate over a record came back empty.
+  ;; (into {} record) returned {} and (reduce kv-fn {} record) was
+  ;; a no-op. (seq record) itself worked (prim_seq has a record case)
+  ;; -- the gap was in the iterator. seq_iter_init now routes records
+  ;; through prim_seq up-front so every downstream consumer (into,
+  ;; reduce, transduce, etc.) walks records as a seq of [k v] pairs.
+  (defrecord PointForInto [x y])
+  (let [p (->PointForInto 1 2)]
+    (testing "(into {} record) collects fields as map entries"
+      (is (= {:x 1 :y 2} (into {} p))))
+    (testing "(into [] record) collects [k v] pairs in declared order"
+      (is (= [[:x 1] [:y 2]] (into [] p))))
+    (testing "(reduce conj #{} record) walks the kv pairs"
+      (is (= #{[:x 1] [:y 2]} (reduce conj #{} p))))))
+
 (deftest defrecord-inline-method-binds-fields
   ;; Real Clojure binds each declared field as a local inside any
   ;; inline protocol method body, so the body can write the field