carray 3.0.0 → 3.0.2

data/ext/carray_factorize.c

@@ -59,7 +59,7 @@
       codes  : narrow unsigned CArray (uint8 / uint16 / uint32), the code
                storage; masked source cells store the type-max sentinel
                (from_codes derives the mask from it, matching categorize).
-      levels : integer CArray (source dtype) of the k distinct values in
+      levels : integer CArray (source data type) of the k distinct values in
                first-appearance order.
     self.__mask_duplicates__(axis) -> boolean CArray of self.shape, true at
       each cell that duplicates an earlier-seen one along axis (per-fiber
@@ -105,13 +105,27 @@
 /* Descend `self` when it is an ORDERABLE Face; *pface keeps the pre-strip Face
    for the re-lift (Qnil when there is nothing to put back). */
 static VALUE
-fz_face_descend (VALUE self, volatile VALUE *pface)
+fz_face_descend (VALUE self, volatile VALUE *pface, const char *name)
 {
   CArray *ca;
   GetCArray(self, ca);
-  if ( ca_is_face(ca) && ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
-    *pface = self;
-    return rb_ca_strip_face_value(self);
+  if ( ca_is_face(ca) ) {
+    if ( ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
+      *pface = self;
+      return rb_ca_strip_face_value(self);
+    }
+    /* A Face that cannot be descended must not flow on undescended: whatever
+       reads it next reads its storage anyway, which is the encoding rather
+       than the values.  A Face in this position normally never arrives --
+       CAConstString and CACategorical define their own members in Ruby -- but
+       the overrides only fire when the Face is the receiver, and this same
+       helper descends the *reference* for locate_addr, where it is the
+       argument. */
+    rb_raise(rb_eArgError,
+             "%s: %s is not orderable by storage (a cell encodes the value "
+             "rather than being it); convert it first -- #to_string for a "
+             "string Face -- or pass .parent to work in storage space",
+             name, rb_obj_classname(self));
   }
   *pface = Qnil;
   return self;
@@ -140,15 +154,7 @@ fz_face_reconcile (VALUE reference, VALUE operand, const char *name)
                                              rb_intern("to_comparable"),
                                              1, operand));
   }
-  if ( rb_obj_is_carray(operand) ) {
-    CArray *op;
-    GetCArray(operand, op);
-    if ( ca_is_face(op) ) {
-      return rb_ca_strip_face_value(operand);
-    }
-  }
-  (void) name;
-  return operand;
+  return ca_face_operand_descend(operand, name);
 }
 
 /* Put the Face back on a value-carrying output. */
@@ -487,7 +493,7 @@ fz_levels_free (fz_levels *l)
      codes  = narrow unsigned CArray; masked source cells store the type-max
               sentinel (0xFF / 0xFFFF / 0xFFFFFFFF), so from_codes reconstructs
               the mask exactly as the mask_duplicates path does.
-     levels = CArray (source dtype) of the k distinct values, in first-appearance
+     levels = CArray (source data type) of the k distinct values, in first-appearance
               (row-major flatten) order.
 */
 static VALUE
@@ -495,7 +501,7 @@ rb_ca_factorize_appearance (VALUE self)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "categorize");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -508,7 +514,7 @@ rb_ca_factorize_appearance (VALUE self)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__factorize_appearance__: integer, float, object, or fixlen dtype required (got %d)", dt);
+             "__factorize_appearance__: integer, float, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__factorize_appearance__: need ndim >= 1");
@@ -535,8 +541,8 @@ rb_ca_factorize_appearance (VALUE self)
   boolean8_t *m;
   ca_size_t   n;
 
-  /* Fiber inner loop, monomorphised per dtype.  WIDEN sign- or zero-extends the
-     element to a 64-bit key; equality within one dtype is preserved. */
+  /* Fiber inner loop, monomorphised per data type.  WIDEN sign- or zero-extends the
+     element to a 64-bit key; equality within one data type is preserved. */
   #define FZ_LOOP(T, WIDEN)                                                  \
     do {                                                                     \
       const T  *ip = (const T *) p_in;                                       \
@@ -664,7 +670,7 @@ rb_ca_factorize_appearance (VALUE self)
     }
   }
 
-  /* Levels: the interned raw values, in source dtype.  CA_FIXLEN carries its
+  /* Levels: the interned raw values, in source data type.  CA_FIXLEN carries its
      element width; numeric / object use bytes = 0. */
   ca_size_t ldim[1];
   ldim[0] = k;
@@ -715,7 +721,7 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__mask_duplicates__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__mask_duplicates__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__mask_duplicates__: need ndim >= 1");
@@ -740,8 +746,8 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
   boolean8_t *m;
   ca_size_t   n;
 
-  /* Fiber inner loop, monomorphised per dtype.  WIDEN sign- or zero-extends the
-     element to a 64-bit key; equality within one dtype is preserved.  The hash
+  /* Fiber inner loop, monomorphised per data type.  WIDEN sign- or zero-extends the
+     element to a 64-bit key; equality within one data type is preserved.  The hash
      interns first appearances, so is_new == 0 flags a duplicate. */
   #define MD_LOOP(T, WIDEN)                                                   \
     do {                                                                      \
@@ -839,7 +845,7 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
 
    INTERNAL (CArray#unique). Collect the distinct values of self in
    first-appearance (row-major flatten) order, one linear pass, no sort. Returns
-   a 1-D CArray of source dtype. Masked cells do not participate.
+   a 1-D CArray of source data type. Masked cells do not participate.
 
    Numeric (integer / float): distinctness follows `==` except NaN collapses to a
    single distinct value (all NaN patterns map to one canonical hash key) and
@@ -863,7 +869,7 @@ rb_ca_unique_flat (VALUE self)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "unique");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -876,7 +882,7 @@ rb_ca_unique_flat (VALUE self)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__unique_flat__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__unique_flat__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__unique_flat__: need ndim >= 1");
@@ -1098,8 +1104,8 @@ fz_intern_all (fz_hash *h, CArray *cv, fz_levels *lv)
    seen-set).  One pass to build the set from `values`, one pass to probe self;
    no sort, peak memory O(distinct values).
 
-   `values` must be a CArray of the same dtype as self (the Ruby surface coerces
-   Array / Range / other-dtype input first).  Masked cells of `values` do not
+   `values` must be a CArray of the same data type as self (the Ruby surface coerces
+   Array / Range / other-type input first).  Masked cells of `values` do not
    enter the set.  Masked cells of self stay masked in the output (membership is
    unknown), reproducing the mask propagation of the retired `contains`
    (self.eq(v)); their boolean payload is false.
@@ -1113,7 +1119,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
 {
   CArray *ca, *cv;
   volatile VALUE face;
-  self     = fz_face_descend(self, &face);
+  self     = fz_face_descend(self, &face, "is_in");
   rvalues  = fz_face_reconcile(face, rvalues, "is_in");
   GetCArray(self, ca);
 
@@ -1127,7 +1133,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__is_in__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__is_in__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__is_in__: need ndim >= 1");
@@ -1137,9 +1143,16 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
     rb_raise(rb_eArgError, "__is_in__: values must be a CArray");
   }
   GetCArray(rvalues, cv);
-  if ( cv->data_type != dt || (dt == CA_FIXLEN && cv->bytes != ca->bytes) ) {
+  if ( cv->data_type != dt ) {
+    rb_raise(rb_eCADataTypeError,
+             "__is_in__: values data type (%s) must match self (%s)",
+             ca_type_name[cv->data_type], ca_type_name[dt]);
+  }
+  if ( dt == CA_FIXLEN && cv->bytes != ca->bytes ) {
     rb_raise(rb_eCADataTypeError,
-             "__is_in__: values dtype must match self (%d)", dt);
+             "__is_in__: a fixlen value is a cell-width blob, so the values "
+             "must be %ld bytes wide like self, not %ld",
+             (long) ca->bytes, (long) cv->bytes);
   }
   if ( cv->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__is_in__: values need ndim >= 1");
@@ -1256,7 +1269,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
    through the discovery-family lanes (NaN collapse, rb_hash + rb_eql, byte
    equality).
 
-   `ref` must be a CArray of the same dtype as self (the Ruby surface coerces
+   `ref` must be a CArray of the same data type as self (the Ruby surface coerces
    first).  Masked cells of `ref` do not enter the map but still occupy their
    flat address (position counts).  Masked cells of self, and cells whose value
    is absent from `ref`, are UNDEF in the output.  "First" occurrence is
@@ -1271,7 +1284,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
      output is an address, so nothing is lifted back. */
   {
     volatile VALUE ref_face;
-    rref = fz_face_descend(rref, &ref_face);
+    rref = fz_face_descend(rref, &ref_face, "locate_addr");
     self = fz_face_reconcile(ref_face, self, "locate_addr");
   }
   GetCArray(self, ca);
@@ -1286,7 +1299,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__locate_addr__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__locate_addr__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__locate_addr__: need ndim >= 1");
@@ -1297,7 +1310,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
   GetCArray(rref, cr);
   if ( cr->data_type != dt || (dt == CA_FIXLEN && cr->bytes != ca->bytes) ) {
     rb_raise(rb_eCADataTypeError,
-             "__locate_addr__: ref dtype must match self (%d)", dt);
+             "__locate_addr__: ref data type must match self (%d)", dt);
   }
   if ( cr->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__locate_addr__: ref need ndim >= 1");
@@ -1521,7 +1534,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
 /* Shared body of __intersection__ (keep_when_hit = 1) and __difference__
    (keep_when_hit = 0): the distinct values of self that are (resp. are not)
    present in `other`, in self's first-appearance order, as a 1-D CArray of
-   self's dtype.  Two seen-sets: `hoth` built from `other` is the probe set;
+   self's data type.  Two seen-sets: `hoth` built from `other` is the probe set;
    `hself` dedups self so each distinct value is decided once.  Masked cells of
    either array do not participate.  Distinctness is the discovery family's per
    lane (numeric `==` + NaN collapse + -0.0 == +0.0, object hash/eql? + NaN
@@ -1531,7 +1544,7 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
 {
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face);
+  self   = fz_face_descend(self, &face, "set relation");
   rother = fz_face_reconcile(face, rother, "set relation");
   GetCArray(self, ca);
 
@@ -1545,7 +1558,7 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "set relation: numeric, object, or fixlen dtype required (got %d)", dt);
+             "set relation: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "set relation: need ndim >= 1");
@@ -1554,8 +1567,16 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
     rb_raise(rb_eArgError, "set relation: other must be a CArray");
   }
   GetCArray(rother, co);
-  if ( co->data_type != dt || (dt == CA_FIXLEN && co->bytes != ca->bytes) ) {
-    rb_raise(rb_eCADataTypeError, "set relation: other dtype must match self (%d)", dt);
+  if ( co->data_type != dt ) {
+    rb_raise(rb_eCADataTypeError,
+             "set relation: other data type (%s) must match self (%s)",
+             ca_type_name[co->data_type], ca_type_name[dt]);
+  }
+  if ( dt == CA_FIXLEN && co->bytes != ca->bytes ) {
+    rb_raise(rb_eCADataTypeError,
+             "set relation: a fixlen value is a cell-width blob, so other "
+             "must be %ld bytes wide like self, not %ld",
+             (long) ca->bytes, (long) co->bytes);
   }
   if ( co->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "set relation: other need ndim >= 1");
@@ -1716,7 +1737,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
 {
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face);
+  self   = fz_face_descend(self, &face, "union");
   rother = fz_face_reconcile(face, rother, "union");
   GetCArray(self, ca);
 
@@ -1730,7 +1751,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__union__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__union__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__union__: need ndim >= 1");
@@ -1740,7 +1761,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
   }
   GetCArray(rother, co);
   if ( co->data_type != dt || (dt == CA_FIXLEN && co->bytes != ca->bytes) ) {
-    rb_raise(rb_eCADataTypeError, "__union__: other dtype must match self (%d)", dt);
+    rb_raise(rb_eCADataTypeError, "__union__: other data type must match self (%d)", dt);
   }
   if ( co->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__union__: other need ndim >= 1");
@@ -1779,7 +1800,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
    first-appearance (row-major flatten) order together with the number of times
    each occurs, one linear pass, no sort.
    Returns [levels, counts]:
-     levels = 1-D CArray of source dtype, the k distinct values in appearance
+     levels = 1-D CArray of source data type, the k distinct values in appearance
               order (identical to __unique_flat__).
      counts = 1-D CA_INT64 of length k, counts[i] = occurrences of levels[i].
    Masked cells do not participate (skipped, not counted). Numeric distinctness
@@ -1793,7 +1814,7 @@ rb_ca_value_counts_flat (VALUE self)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "value_counts");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -1806,7 +1827,7 @@ rb_ca_value_counts_flat (VALUE self)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__value_counts_flat__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__value_counts_flat__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__value_counts_flat__: need ndim >= 1");
@@ -1979,7 +2000,7 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__nunique__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__nunique__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__nunique__: need ndim >= 1");
@@ -2126,7 +2147,7 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__is_mode__: numeric, object, or fixlen dtype required (got %d)", dt);
+             "__is_mode__: numeric, object, or fixlen data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__is_mode__: need ndim >= 1");
@@ -2332,7 +2353,7 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "mode");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -2344,7 +2365,7 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
     break;
   default:
     rb_raise(rb_eCADataTypeError,
-             "__mode_axis__: numeric dtype required (got %d)", dt);
+             "__mode_axis__: numeric data type required (got %d)", dt);
   }
   if ( ca->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__mode_axis__: need ndim >= 1");

data/ext/carray_hold.c

@@ -5,7 +5,7 @@
   (see devel/PROPOSAL_UNMASK_FILL_METHOD.md).
 
   Hold copies a cell's bytes into masked cells with no arithmetic and no
-  per-dtype behavior, so a single ca->bytes-width memcpy walk covers every
+  per-type behavior, so a single ca->bytes-width memcpy walk covers every
   data_type -- numeric, complex, bool, object (VALUE-slot byte copy of an
   already-live value), fixlen, and Face storage.  This native does forward
   hold along one axis only and returns a fresh same-shape entity; the

data/ext/carray_index_classifier.c

@@ -37,7 +37,6 @@ static ID ca_classifier_id_excl_end = 0;
 /* Symbol cache — see the range-macro comment above for why this
    file keeps its own copy independent of carray_access.c. */
 
-static VALUE ca_classifier_sym_star  = Qundef;
 static VALUE ca_classifier_sym_perc  = Qundef;
 static VALUE ca_classifier_sym_under = Qundef;
 static VALUE ca_classifier_sym_gt    = Qundef;   /* :> slab-iterator marker */
@@ -46,8 +45,7 @@ static VALUE ca_classifier_sym_tilde = Qundef;   /* :~ rubber-dim alias for `fal
 static inline void
 ca_classifier_sym_cache_init (void)
 {
-  if ( ca_classifier_sym_star == Qundef ) {
-    ca_classifier_sym_star  = ID2SYM(rb_intern("*"));
+  if ( ca_classifier_sym_perc == Qundef ) {
     ca_classifier_sym_perc  = ID2SYM(rb_intern("%"));
     ca_classifier_sym_under = ID2SYM(rb_intern("_"));
     ca_classifier_sym_gt    = ID2SYM(rb_intern(">"));
@@ -166,7 +164,7 @@ ca_classifier_try_address_fast_path (ca_classifier_ctx_t *ctx)
 /* Single-character alphabetic Symbols (`:a`-`:z` / `:A`-`:Z`) are
    reserved for future contraction notation.  Raises
    NotImplementedError rather than the generic IndexError.  The
-   caller passes any Symbol that is not `:_` / `:*` / `:%`; a
+   caller passes any Symbol that is not `:_` / `:%`; a
    non-reserved Symbol returns without action. */
 static inline void
 ca_classifier_check_reserved_contraction_symbol (VALUE sym)
@@ -763,12 +761,6 @@ ca_classifier_try_argc1_special (ca_classifier_ctx_t *ctx)
              ca_type_name[cs->data_type]);
   }
 
-  /* :* → UNBOUND_REPEAT. */
-  if ( arg == ca_classifier_sym_star ) {
-    info->type = CA_REG_UNBOUND_REPEAT;
-    return 1;
-  }
-
   /* ndim > 1 with Integer → ADDRESS.  Fixnum was caught by the
      fast path; this branch handles Bignum. */
   if ( ctx->ca_ndim > 1 && rb_obj_is_kind_of(arg, rb_cInteger) ) {
@@ -832,7 +824,7 @@ rb_ca_scan_index_v2 (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
   }
 
   /* argv[0] = multi-char Symbol → METHOD_CALL.  Single-char
-     specials (:_ / :* / :%) fall through the strlen check and are
+     specials (:_ / :%) fall through the strlen check and are
      handled downstream (argc == 1 special / fast paths / main
      loop).  Single-char alphabetic reserved-contraction Symbols
      also fall through here and are raised later by the per-axis
@@ -859,20 +851,15 @@ rb_ca_scan_index_v2 (int ca_ndim, ca_size_t *ca_dim, ca_size_t ca_elements,
      when argc == 1 && ndim == 1 falls through to the POINT 1-D
      classification below. */
 
-  /* CAREFUL: pre-scan for :% / :*.  Either Symbol at any position
-     pins the final REG and short-circuits both the main loop and
-     the argc / ndim validation below — skipping the pre-scan lets
-     the ndim mismatch check fire before the Symbol is
-     recognised. */
+  /* CAREFUL: pre-scan for :%.  The Symbol at any position pins the
+     final REG and short-circuits both the main loop and the argc /
+     ndim validation below — skipping the pre-scan lets the ndim
+     mismatch check fire before the Symbol is recognised. */
   for (i = 0; i < ctx.argc; i++) {
     if ( ctx.argv[i] == ca_classifier_sym_perc ) {
       info->type = CA_REG_REPEAT;
       return;
     }
-    if ( ctx.argv[i] == ca_classifier_sym_star ) {
-      info->type = CA_REG_UNBOUND_REPEAT;
-      return;
-    }
   }
 
   ca_classifier_expand_rubber_dim(&ctx);
@@ -941,7 +928,6 @@ rb_ca_s_scan_index_v2 (VALUE self, VALUE rdim, VALUE ridx)
     case CA_REG_GRID:
     case CA_REG_MAPPING:
     case CA_REG_METHOD_CALL:
-    case CA_REG_UNBOUND_REPEAT:
     case CA_REG_MEMBER:
     case CA_REG_ATTRIBUTE:
       break;

data/ext/carray_internal.h

@@ -59,8 +59,41 @@ void ca_bit_pack   (const boolean8_t *src, ca_size_t elements, ca_size_t pbytes,
 void    ca_lazy_arena_enter   (void);
 void    ca_lazy_arena_exit    (void);
 void   *ca_lazy_arena_acquire (ca_size_t bytes);
+void   *ca_lazy_arena_acquire_object (ca_size_t n_elements);
 void    ca_lazy_arena_release (void *ptr);
 
+/* ---- CA_OBJECT GC guard (carray_lazy.c) ----------------------------------
+
+   A CA_OBJECT cell is a VALUE, and a materialise writes those cells into a
+   buffer no Ruby object owns.  Object-lane kernels call rb_funcall per cell,
+   so a collection can happen halfway through and free what has been written
+   so far.  Hold the buffer while it is exposed like that, and after the
+   materialise until a Ruby object takes ownership of it.
+
+   The cells must already be valid VALUEs, so a fresh buffer is Qnil-filled
+   before it is held.  ca_gc_hold_push returns the depth to hand back to
+   ca_gc_hold_pop_to, so nested holds unwind in order. */
+
+int     ca_gc_hold_push   (void *ptr, ca_size_t n_elements);
+void    ca_gc_hold_pop_to (int depth);
+
+/* ---- Attaching several parents (carray_core.c) ---------------------------
+
+   Attach all of list[0..n-1] or none: if one attach raises, those already
+   attached are detached before the raise propagates. */
+
+void    ca_attach_all (CArray **list, int32_t n);
+
+/* ---- Filling a result Ruby does not own yet (carray_copy.c) ---------------
+
+   A C builder that allocates its result with carray_new / ca_template and
+   then reads the source into it holds a struct no Ruby object owns until
+   ca_wrap_struct.  A read that raises (a lazy conversion) would leave it
+   behind.  ca_fill_or_free runs fill(arg) under rb_protect and, if it
+   raises, frees `co` before the raise propagates. */
+
+void    ca_fill_or_free (CArray *co, VALUE (*fill)(VALUE), VALUE arg);
+
 /* Non-zero iff the object is an element-wise lazy view (CAMonOp / CABinOp /
    CABinCmp / CAMonCmp / CALazyMarker).  The streaming branch of the
    mkkernel-generated reduction kernels tests this to decide whether it can
@@ -111,10 +144,10 @@ VALUE    rb_ca_fake_new (VALUE cary, int8_t data_type, ca_size_t bytes);
 CARepeat *ca_repeat_new (CArray *carray, int8_t ndim, ca_size_t *count);
 VALUE     rb_ca_repeat_new (VALUE cary, int8_t ndim, ca_size_t *count);
 
-/* ca_obj_unbound_repeat.c */
-VALUE    rb_ca_ubrep_new (VALUE cary, int32_t rep_ndim, ca_size_t *rep_dim);
-
 /* ca_obj_reduce.c */
 CAReduce *ca_reduce_new (CArray *carray, ca_size_t count, ca_size_t offset);
 
+/* carray_broadcast.c */
+void     ca_broadcast_to_destination (VALUE dst, volatile VALUE *src);
+
 #endif /* CARRAY_INTERNAL_H */

data/ext/carray_kernels_bincmp.c

@@ -34,6 +34,7 @@ static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
 #endif
 
 #include "ca_op_powi.h"
+#include "ca_op_cmplx64.h"
 
 /* ===== bincmp feq ============================================ */