Add MINO_MAP_ENTRY value type

JVM Clojure's MapEntry is vector-shaped but distinct: (key [1 2])
throws because a plain vector isn't a Map.Entry. mino conflated
the two, so key.cljc and val.cljc failed on the throw assertions.

Add a distinct MINO_MAP_ENTRY type carrying (k, v). seq of a map /
sorted-map / record now produces MAP_ENTRY values; find /
clojure.lang.MapEntry/create likewise. key / val accept only
MAP_ENTRY. vector? / coll? / counted? / associative? /
reversible? / sequential? return true on it. Equality with
[k v] is element-wise via the cross-type sequential path; hash
matches a 2-vector so it round-trips through hash maps.
first / rest / nth / get / count / empty? / vector destructuring
/ compare / into-map / conj-map / conj-of-MAP_ENTRY all dispatch
through it. New C primitive `map-entry` constructs one.

aset is intentionally not implemented for MAP_ENTRY (entries are
immutable in JVM Clojure too).

Internal 1476 / 7089 / 0. key.cljc 8/17 -> 17/17, val.cljc 7/16 ->
16/16, plus merge / sort / sort_by / zipmap / seq fixes for the
MAP_ENTRY contagion through into / conj / compare / hash. External
suite 209 -> 211 OK.

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

Author: leifericf

CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## v0.100.32
+
+### Add `MINO_MAP_ENTRY` value type
+
+JVM Clojure's MapEntry is a vector-shaped seq returned by `first` /
+`seq` of a map; `key` and `val` accept it but throw on a plain
+2-vector. mino conflated map entries and 2-vectors, so
+`(p/thrown? (key [1 2]))` failed. Add a distinct `MINO_MAP_ENTRY`
+type with `(k, v)` slots, GC mark + verify, hash that matches a
+2-vector (so cross-type equality works in hash maps), `(type x)`
+returns `:map-entry`, and `vector?` / `coll?` / `counted?` /
+`associative?` / `reversible?` / `sequential?` return true on it.
+Equality with `[k v]` is element-wise via the existing cross-type
+sequential path. `seq` of a map / sorted-map / record now produces
+MAP_ENTRY values; `find`, `first`, `rest`, `nth`, `get`, `count`,
+`empty?`, vector destructuring, `compare`, `into`-map, `conj`-map,
+and `conj`-of-MAP_ENTRY all dispatch through it. `key` / `val` in
+`src/core.clj` accept only MAP_ENTRY and throw otherwise.
+`clojure.lang.MapEntry/create` now constructs a MAP_ENTRY (via the
+new `map-entry` C primitive). `aset` is intentionally not
+implemented for MAP_ENTRY since entries are immutable.
+
+External `key.cljc` 8/17 -> 17/17, `val.cljc` 7/16 -> 16/16. External
+suite: 209 -> 211 OK.
+
 ## v0.100.31
 
 ### `(float x)` narrows to 32-bit float precision

src/collections/clone.c

@@ -213,6 +213,7 @@ static mino_val_t *clone_val(mino_state_t *dst, const mino_val_t *v)
     case MINO_RECORD:
     case MINO_FUTURE:
     case MINO_HOST_ARRAY:
+    case MINO_MAP_ENTRY:
         return NULL;
     case MINO_UUID:
         return mino_uuid_from_bytes(dst, v->as.uuid.bytes);

src/collections/map.c

@@ -187,6 +187,15 @@ uint32_t hash_val(const mino_val_t *v)
         }
         return h;
     }
+    case MINO_MAP_ENTRY: {
+        /* Hashes as a 2-vector of (k, v) so cross-type equality with
+         * MINO_VECTOR also gives identical hashes (so a hash-map keyed
+         * by entries vs. by 2-vectors still compares equal). */
+        h = fnv_mix(h, 0x09);
+        h = hash_uint32_bytes(h, hash_val(v->as.map_entry.k));
+        h = hash_uint32_bytes(h, hash_val(v->as.map_entry.v));
+        return h;
+    }
     case MINO_MAP: {
         /* XOR-fold of per-entry hashes for order independence. Each entry's
          * hash mixes key and value hashes with a prime to avoid (k ^ v)

src/collections/val.c

@@ -228,6 +228,14 @@ mino_val_t *mino_cons(mino_state_t *S, mino_val_t *car, mino_val_t *cdr)
     return v;
 }
 
+mino_val_t *mino_map_entry(mino_state_t *S, mino_val_t *k, mino_val_t *v)
+{
+    mino_val_t *e = alloc_val(S, MINO_MAP_ENTRY);
+    e->as.map_entry.k = k;
+    e->as.map_entry.v = v;
+    return e;
+}
+
 /* ------------------------------------------------------------------------- */
 /* Host arrays                                                               */
 /* ------------------------------------------------------------------------- */
@@ -626,7 +634,8 @@ static int eq_seq_like_force(mino_state_t *S, const mino_val_t *a,
 static int is_sequential(mino_type_t t)
 {
     return (t == MINO_CONS || t == MINO_VECTOR || t == MINO_EMPTY_LIST
-            || t == MINO_LAZY || t == MINO_CHUNKED_CONS);
+            || t == MINO_LAZY || t == MINO_CHUNKED_CONS
+            || t == MINO_MAP_ENTRY);
 }
 
 /*
@@ -666,7 +675,7 @@ static void eq_seq_step(const mino_val_t **cur, size_t *idx)
         }
         return;
     }
-    /* MINO_VECTOR */
+    /* MINO_VECTOR or MINO_MAP_ENTRY (treated as 2-element vector). */
     (*idx)++;
 }
 
@@ -691,10 +700,12 @@ static int eq_seq_like(const mino_val_t *a, const mino_val_t *b)
         a_end = (ca == NULL || ca->type == MINO_NIL
                  || ca->type == MINO_EMPTY_LIST
                  || (ca->type == MINO_VECTOR && ia >= ca->as.vec.len)
+                 || (ca->type == MINO_MAP_ENTRY && ia >= 2)
                  || ca->type == MINO_LAZY /* unrealized */);
         b_end = (cb == NULL || cb->type == MINO_NIL
                  || cb->type == MINO_EMPTY_LIST
                  || (cb->type == MINO_VECTOR && ib >= cb->as.vec.len)
+                 || (cb->type == MINO_MAP_ENTRY && ib >= 2)
                  || cb->type == MINO_LAZY /* unrealized */);
 
         if (a_end && b_end) return 1;
@@ -703,11 +714,15 @@ static int eq_seq_like(const mino_val_t *a, const mino_val_t *b)
         if (ca->type == MINO_CONS) ea = ca->as.cons.car;
         else if (ca->type == MINO_CHUNKED_CONS)
             ea = ca->as.chunked_cons.chunk->as.chunk.vals[ia];
+        else if (ca->type == MINO_MAP_ENTRY)
+            ea = ia == 0 ? ca->as.map_entry.k : ca->as.map_entry.v;
         else ea = vec_nth(ca, ia);
 
         if (cb->type == MINO_CONS) eb = cb->as.cons.car;
         else if (cb->type == MINO_CHUNKED_CONS)
             eb = cb->as.chunked_cons.chunk->as.chunk.vals[ib];
+        else if (cb->type == MINO_MAP_ENTRY)
+            eb = ib == 0 ? cb->as.map_entry.k : cb->as.map_entry.v;
         else eb = vec_nth(cb, ib);
 
         if (!mino_eq(ea, eb)) return 0;
@@ -1020,6 +1035,9 @@ int mino_eq(const mino_val_t *a, const mino_val_t *b)
          * (object-array 3) calls are NOT `=` even if their elements
          * match. */
         return a == b;
+    case MINO_MAP_ENTRY:
+        return mino_eq(a->as.map_entry.k, b->as.map_entry.k)
+            && mino_eq(a->as.map_entry.v, b->as.map_entry.v);
     }
     return 0;
 }
@@ -1053,22 +1071,28 @@ static int eq_seq_like_force(mino_state_t *S, const mino_val_t *a,
 
         a_end = (ca == NULL || ca->type == MINO_NIL
                  || ca->type == MINO_EMPTY_LIST
-                 || (ca->type == MINO_VECTOR && ia >= ca->as.vec.len));
+                 || (ca->type == MINO_VECTOR && ia >= ca->as.vec.len)
+                 || (ca->type == MINO_MAP_ENTRY && ia >= 2));
         b_end = (cb == NULL || cb->type == MINO_NIL
                  || cb->type == MINO_EMPTY_LIST
-                 || (cb->type == MINO_VECTOR && ib >= cb->as.vec.len));
+                 || (cb->type == MINO_VECTOR && ib >= cb->as.vec.len)
+                 || (cb->type == MINO_MAP_ENTRY && ib >= 2));
 
         if (a_end && b_end) return 1;
         if (a_end || b_end) return 0;
 
         if (ca->type == MINO_CONS) ea = ca->as.cons.car;
         else if (ca->type == MINO_CHUNKED_CONS)
             ea = ca->as.chunked_cons.chunk->as.chunk.vals[ia];
+        else if (ca->type == MINO_MAP_ENTRY)
+            ea = ia == 0 ? ca->as.map_entry.k : ca->as.map_entry.v;
         else ea = vec_nth(ca, ia);
 
         if (cb->type == MINO_CONS) eb = cb->as.cons.car;
         else if (cb->type == MINO_CHUNKED_CONS)
             eb = cb->as.chunked_cons.chunk->as.chunk.vals[ib];
+        else if (cb->type == MINO_MAP_ENTRY)
+            eb = ib == 0 ? cb->as.map_entry.k : cb->as.map_entry.v;
         else eb = vec_nth(cb, ib);
 
         if (!mino_eq_force(S, ea, eb)) return 0;

src/core.clj

@@ -836,11 +836,12 @@
   "Returns true if x supports assoc (maps and vectors)."
   [x]
   (let [t (type x)]
-    (or (= t :map) (= t :vector) (= t :sorted-map))))
+    (or (= t :map) (= t :vector) (= t :sorted-map) (= t :map-entry))))
 (defn reversible?
   "Returns true if x supports rseq (vectors and sorted collections)."
   [x] (let [t (type x)]
-        (or (= t :vector) (= t :sorted-map) (= t :sorted-set))))
+        (or (= t :vector) (= t :sorted-map) (= t :sorted-set)
+            (= t :map-entry))))
 (defn any? "Returns true for any argument." [x] true)
 (defn seqable?
   "Returns true if (seq x) is supported."
@@ -912,8 +913,20 @@
 
 ;; --- Map entry accessors ---
 
-(defn key "Returns the key of a map entry." [entry] (first entry))
-(defn val "Returns the value of a map entry." [entry] (second entry))
+(defn key
+  "Returns the key of a map entry. Throws on values that are not
+   map entries (a literal 2-vector, for instance)."
+  [entry]
+  (if (= :map-entry (type entry))
+    (first entry)
+    (throw (str "key: expected a map entry, got " (type entry)))))
+(defn val
+  "Returns the value of a map entry. Throws on values that are not
+   map entries (a literal 2-vector, for instance)."
+  [entry]
+  (if (= :map-entry (type entry))
+    (second entry)
+    (throw (str "val: expected a map entry, got " (type entry)))))
 
 (defn counted?
   "Returns true if (count x) is a constant-time operation. Per
@@ -923,7 +936,7 @@
   [x]
   (let [t (type x)]
     (or (= t :vector) (= t :map) (= t :set)
-        (= t :sorted-map) (= t :sorted-set))))
+        (= t :sorted-map) (= t :sorted-set) (= t :map-entry))))
 
 (defn bounded-count
   "Returns the count of coll, but stops counting at n."
@@ -3193,12 +3206,12 @@
 (def clojure.lang.IPending :future)
 (def clojure.lang.BigInt :bigint)
 
-;; Bridge `clojure.lang.MapEntry/create` to a 2-vector constructor.
+;; Bridge `clojure.lang.MapEntry/create` to mino's MAP_ENTRY type.
 ;; Cross-dialect tests use it under `:default` to build a map entry
-;; literal; mino represents map entries as 2-vectors and `key`/`val`
-;; already accept that shape, so the only missing piece is the ctor.
+;; literal; the C primitive `map-entry` returns a MINO_MAP_ENTRY,
+;; which `key`/`val` accept.
 (ns clojure.lang.MapEntry)
-(defn create [k v] [k v])
+(defn create [k v] (clojure.core/map-entry k v))
 (in-ns 'clojure.core)
 
 ;; In Clojure JVM the primed arithmetic forms (`+'`, `-'`, `*'`,

src/eval/bindings.c

@@ -50,6 +50,10 @@ static int bind_vec_destructure(mino_state_t *S, mino_env_t *env,
             lst = mino_cons(S, vec_nth(val, j), lst);
         }
         args = lst;
+    } else if (val != NULL && val->type == MINO_MAP_ENTRY) {
+        /* Map entry behaves like a 2-vector for destructuring. */
+        args = mino_cons(S, val->as.map_entry.k,
+                            mino_cons(S, val->as.map_entry.v, mino_nil(S)));
     }
     for (i = 0; i < plen; i++) {
         mino_val_t *p = vec_nth(pattern, i);

src/eval/print.c

@@ -450,6 +450,16 @@ void mino_print_to(mino_state_t *S, FILE *out, const mino_val_t *v)
         fputc('"', out);
         return;
     }
+    case MINO_MAP_ENTRY: {
+        /* Print as `[k v]` so map-entry round-trips through equality
+         * with a 2-vector and matches Clojure's pr/print form. */
+        fputc('[', out);
+        mino_print_to(S, out, v->as.map_entry.k);
+        fputc(' ', out);
+        mino_print_to(S, out, v->as.map_entry.v);
+        fputc(']', out);
+        return;
+    }
     case MINO_HOST_ARRAY: {
         /* Mirror Clojure JVM's #object[...] form for arrays since
          * arrays don't round-trip through the reader. */

src/eval/special.c

@@ -716,6 +716,7 @@ mino_val_t *eval_impl(mino_state_t *S, mino_val_t *form, mino_env_t *env, int ta
     case MINO_UUID:
     case MINO_REGEX:
     case MINO_HOST_ARRAY:
+    case MINO_MAP_ENTRY:
         return form;
     case MINO_SYMBOL:
         return eval_symbol(S, form, env);

src/gc/driver.c

@@ -454,6 +454,10 @@ void gc_trace_children(mino_state_t *S, gc_hdr_t *h)
             }
             break;
         }
+        case MINO_MAP_ENTRY:
+            gc_mark_child_push(S, v->as.map_entry.k);
+            gc_mark_child_push(S, v->as.map_entry.v);
+            break;
         case MINO_CHUNKED_CONS:
             gc_mark_child_push(S, v->as.chunked_cons.chunk);
             gc_mark_child_push(S, v->as.chunked_cons.more);

src/gc/minor.c

@@ -276,6 +276,10 @@ static void gc_verify_remset_complete(mino_state_t *S)
                 }
                 break;
             }
+            case MINO_MAP_ENTRY:
+                gc_verify_check(S, h, v->as.map_entry.k);
+                gc_verify_check(S, h, v->as.map_entry.v);
+                break;
             case MINO_CHUNKED_CONS:
                 gc_verify_check(S, h, v->as.chunked_cons.chunk);
                 gc_verify_check(S, h, v->as.chunked_cons.more); break;