carray 3.0.6 → 3.0.7

data/lib/carray/frame/group.rb

@@ -148,7 +148,7 @@ class CAFrame
   # as an empty reduction does: UNDEF for +mean+, 0 for +count+ and +sum+.
   # A row whose time is masked belongs to no bin.
   #
-  # +by:+ (a column name or an Array of them) bins each group of rows on its
+  # +by:+ (a column name, a CArray key or an Array of them) bins each group of rows on its
   # own: a group is the rows sharing the +by:+ values and a bin. The result
   # then has no index: the +by:+ columns and the bin times (named +name+)
   # are its first columns, the groups in the order their +by:+ values first
@@ -163,7 +163,9 @@ class CAFrame
   # @param origin [nil, Time, String, CATime::Element] where bins start.
   # @param label [:left, :right] which end of a bin names it and is closed.
   # @param fill [Boolean] whether bins with no rows are rows of the result.
-  # @param by [nil, String, Array<String>] columns whose groups are binned apart.
+  # @param by [nil, String, CArray, Array<String, CArray>] columns whose groups
+  #   are binned apart; a CArray key (one value per row, as group_by takes it)
+  #   is labelled "key0", "key1", ... by its place.
   # @return [GroupedFrame]
   # @raise [ArgumentError] when the column is not a CATime, or +label:+ is
   #   neither :left nor :right, or +by:+ names the time column.
@@ -191,13 +193,18 @@ class CAFrame
   # resample with by:. A group is a (by values, bin) pair, coded as
   # group * bins + bin, so the codes run through the groups in the order their
   # by values first appear and through each group's bins in time order.
+  # A by: key is a column name or, as group_by takes it, a CArray of one
+  # value per row; a CArray key is labelled "key0", "key1", ... by its place.
   private def resample_by(name, time, bins, grid, by, fill)
-    by_names = column_keys(Array(by), "resample")
-    raise ArgumentError, "resample: by: names no column" if by_names.empty?
-    if by_names.include?(name)
+    keys = by.is_a?(Array) ? by : [by]
+    raise ArgumentError, "resample: by: names no column" if keys.empty?
+    keys.each { |k| column_key(k, "resample") unless k.is_a?(CArray) }
+    if keys.include?(name)
       raise ArgumentError, "resample: by: names the time column #{name.inspect}"
     end
-    by_cols = by_names.map { |n| key_column(n, "resample") }
+    by_names = keys.each_with_index.map { |k, i| k.is_a?(String) ? k : "key#{i}" }
+    CAFrame.__send__(:refuse_repeated_names, by_names + [name], "resample")
+    by_cols = keys.map { |k| key_column(k, "resample") }
     gcat = CACategorical.send(:from_keys, by_cols)
     ng   = gcat.labels.size
     nb   = grid.elements
@@ -223,7 +230,7 @@ class CAFrame
       parts + [blabels[b]]
     end
     cat = CACategorical.from_codes(codes, labels)
-    key_names = by_names + (@columns.key?(name) ? [name] : [])
+    key_names = keys.grep(String) + (@columns.key?(name) ? [name] : [])
     GroupedFrame.new(self, cat, "group", key_names, label_columns: columns)
   end
 
@@ -233,9 +240,19 @@ class CAFrame
   # or one-year grid and then given the bins' unit, as the labels without
   # fill: are.
   private def resample_grid(bins, unit)
-    base = CATime::Resolution.parse(unit).base
-    if %i[Y M].include?(base)
-      CArray.time_range(bins.min, bins.max, unit: base, step: unit).to_unit(bins.unit)
+    res = CATime::Resolution.parse(unit)
+    if %i[Y M].include?(res.base)
+      months = res.base == :Y ? res.count * 12 : res.count
+      grid = CArray.time_range(bins.min, bins.max, unit: :M, step: "#{months} months")
+      # A key coarser than the bins holds one bin for several grid points.
+      # key-labels: the bins of a grid, labelled by the caller
+      grid.to_unit(bins.unit).unique(sort: true)
+    elsif CATimeUnitAlgebra.ratio(res, bins.unit).denominator != 1
+      # A step finer than the key is stepped in its own unit; the key holds
+      # one bin for several of its points.
+      grid = CArray.time_range(bins.min, bins.max, unit: res.base, step: unit)
+      # key-labels: the bins of a grid, labelled by the caller
+      grid.to_unit(bins.unit).unique(sort: true)
     else
       CArray.time_range(bins.min, bins.max, unit: bins.unit, step: unit)
     end
@@ -376,7 +393,7 @@ class CAFrame
     end
     cols = CAFrame.__send__(:quantile_columns, named)
     return CAFrame.new(cols) unless keep_rows
-    return CAFrame.new(cols, axis_name: @axis_name, index: @index)
+    return CAFrame.new(cols, axis_name: @axis_name, index: @index&.copy)
   end
 
   # The five columns a quantile gives a column, by name.
@@ -391,13 +408,10 @@ class CAFrame
   private_constant :QUANTILE_SUFFIXES
 
   private def reduce_all_rows (reduction, *names, min_count: nil, fill_value: nil, keep_rows: false, args: [])
-    if fill_value.is_a?(Hash)
-      unknown = fill_value.keys - column_names
-      unless unknown.empty?
-        raise ArgumentError,
-              "#{reduction}: fill_value names no column #{unknown.map(&:inspect).join(', ')}"
-      end
-    end
+    walk = ColumnWalk.new(self)
+    walk.__send__(:refuse_unknown_fill_columns, reduction, fill_value)
+    walk.__send__(:refuse_wrong_reduction_arguments, reduction, args,
+                  { min_count: min_count }.compact)
     return reduce_down_the_rows(reduction, names, keep_rows, args) do |name|
       fill = fill_value.is_a?(Hash) ? fill_value[name] : fill_value
       { min_count: min_count, fill_value: fill }.compact
@@ -425,7 +439,7 @@ class CAFrame
     end
     return CAFrame.new(named) unless keep_rows
     return out if out.is_a?(CArray)
-    return CAFrame.new(named, axis_name: @axis_name, index: @index)
+    return CAFrame.new(named, axis_name: @axis_name, index: @index&.copy)
   end
 
   # Values computed down the rows, one per row, as +GroupedFrame+ computes
@@ -459,8 +473,9 @@ class CAFrame
     out = ColumnWalk.new(self).over(operation, names, [], [], keywords) do |col, _|
       col.public_send(operation, **(col.ndim > 1 ? keywords.merge(axis: 0) : keywords))
     end
+    ColumnWalk.new(self).__send__(:refuse_no_column_on_rows, operation, out, @nrow)
     return out if out.is_a?(CArray)
-    return CAFrame.new(out, axis_name: @axis_name, index: @index)
+    return CAFrame.new(out, axis_name: @axis_name, index: @index&.copy)
   end
 
   # The frame's own walk over its columns: the one rule of a frame-wide verb
@@ -514,6 +529,8 @@ class CAFrame
     walk = ColumnWalk.new(self)
     if distance.nil?
       step = n.nil? ? 1 : n
+      # A wrong n: would otherwise read as no column having a lag.
+      CArray.float64(1).lag(step)
       cols = walk.over(:lag, names, [], [step]) do |col, _|
         (col.ndim > 1 ? col.lag(step, axis: 0) : col.lag(step)).copy
       end
@@ -524,7 +541,7 @@ class CAFrame
       end
     end
     return cols if cols.is_a?(CArray)
-    CAFrame.new(cols, axis_name: @axis_name, index: @index)
+    CAFrame.new(cols, axis_name: @axis_name, index: @index&.copy)
   end
 
   # [key name, key, sign, width] for a lag by distance; nil for one by rows.
@@ -548,7 +565,7 @@ class CAFrame
       on_name = column_key(on, verb)
     end
     key   = key_column(on_name, verb)
-    unless key.is_a?(CATime) || key.is_a?(CATimedelta) || (!key.face? && key.numeric?)
+    unless key.is_a?(CATime) || key.is_a?(CATimedelta) || (!key.face? && key.numeric? && !key.complex?)
       raise ArgumentError,
             "#{verb}: the key #{on_name.inspect} is #{CArray::Inspector.type_label(key)}; " \
             "a distance is taken along a time, a duration or a number"
@@ -804,7 +821,7 @@ class GroupedFrame
       cols[out] =
         case reduction
         when Symbol
-          group_reduce(@frame[in_name], reduction, *args, **options)
+          group_reduce(@frame.__send__(:named_column, in_name, "aggregate"), reduction, *args, **options)
         when Proc
           unless args.empty? && options.empty?
             raise ArgumentError, "aggregate: a Proc reduction takes no arguments (#{out.inspect})"
@@ -827,6 +844,7 @@ class GroupedFrame
   # first appear; a group whose Hash lacks a name is UNDEF there, as
   # +from_records+ reads a record that lacks a key.
   def table(keep_rows: false)
+    raise ArgumentError, "table: give a block" unless block_given?
     refuse_changed_rows("table")
     outs = []
     each_group_frame do |g|
@@ -953,7 +971,7 @@ class GroupedFrame
     end
     cols = CAFrame.__send__(:quantile_columns, named)
     return result_frame(cols, false) unless keep_rows
-    return CAFrame.new(cols, axis_name: @frame.axis_name, index: @frame.index)
+    return CAFrame.new(cols, axis_name: @frame.axis_name, index: @frame.index&.copy)
   end
 
   # The same convenience for the reductions that take no min_count: or
@@ -1041,7 +1059,7 @@ class GroupedFrame
       col[addr, *([nil] * (col.ndim - 1))].copy
     end
     return out if out.is_a?(CArray)
-    CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index)
+    CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index&.copy)
   end
 
   def order (*names, descending: false, method: :ordinal, kind: :quick)
@@ -1104,11 +1122,10 @@ class GroupedFrame
     when :ffill, :bfill
       @frame.__send__(:refuse_if_frozen)
       key = @frame.__send__(:column_key, name, "fill")
-      col = @frame[key]
+      col = @frame.__send__(:named_column, key, "fill")
       # A row in no group is UNDEF in the fill, so writing it changes nothing.
       held = group_transform(col, :strip_mask, [], { method: method_or_value })
-      target = col.is_masked
-      col[target] = held[target] if target.any
+      @frame.__send__(:write_filled_cells, col, held)
     when :linear
       @frame.__send__(:refuse_if_frozen)
       key = @frame.__send__(:column_key, name, "fill")
@@ -1122,7 +1139,7 @@ class GroupedFrame
     when Symbol
       raise ArgumentError,
             "fill: unknown method #{method_or_value.inspect} " \
-            "(:ffill | :bfill, or a constant fill value)"
+            "(:ffill | :bfill | :linear, or a constant fill value)"
     else
       @frame.fill(name, method_or_value)
     end
@@ -1230,6 +1247,7 @@ class GroupedFrame
   #   shape [ngroup].
   def filter (**options)
     CAFrame.__send__(:refuse_filter_keywords, options, "filter")
+    raise ArgumentError, "filter: give a block" unless block_given?
     refuse_changed_rows("filter")
     chosen = yield(self)
     unless chosen.is_a?(CArray) && chosen.data_type == :boolean
@@ -1278,17 +1296,27 @@ class GroupedFrame
     out = over_named_columns(op, names, @key_names, args, keywords) do |col|
       group_transform(col, op, args, keywords)
     end
+    refuse_no_column_on_rows(op, out, @frame.nrow)
     return out if out.is_a?(CArray)
-    CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index)
+    CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index&.copy)
   end
 
   # A column's within-group transform: an N-D column runs along the rows.
   private def group_transform(col, op, args, keywords)
+    return group_lag_by_rows(col, *args) if op == :lag && col.face? && !col.__send__(:holds_new_values?)
     it = col.group_by_category(@cat)
     keywords = keywords.merge(axis: 0) if col.ndim > 1
     it.public_send(op, *args, **keywords)
   end
 
+  # A Face that cannot hold new values answers an iterator's lag in object
+  # cells. Reading each cell from the row it lags keeps the Face, as
+  # lag(before:) does.
+  private def group_lag_by_rows(col, step)
+    rows = CArray.int64(@frame.nrow).seq.group_by_category(@cat).lag(step)
+    col[rows, *([nil] * (col.ndim - 1))].copy
+  end
+
   # Each result gets its own index.
   private def label_index
     return @index.copy if @index
@@ -1302,13 +1330,8 @@ class GroupedFrame
     refuse_key_as_result(reduction, names) unless keep_rows
     keywords = keywords.compact
     fills = keywords.delete(:fill_value)
-    if fills.is_a?(Hash)
-      unknown = fills.keys - @frame.column_names
-      unless unknown.empty?
-        raise ArgumentError,
-              "#{reduction}: fill_value names no column #{unknown.map(&:inspect).join(', ')}"
-      end
-    end
+    refuse_unknown_fill_columns(reduction, fills)
+    refuse_wrong_reduction_arguments(reduction, args, keywords)
     named = {}
     out = over_named_columns(reduction, names, @key_names, args) do |col, name|
       fill = fills.is_a?(Hash) ? fills[name] : fills
@@ -1322,7 +1345,7 @@ class GroupedFrame
     # labels beside it.
     if keep_rows
       return out if out.is_a?(CArray)
-      return CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index)
+      return CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index&.copy)
     end
     result_frame(named, false)
   end
@@ -1360,7 +1383,7 @@ class GroupedFrame
       return CAFrame.new(@label_columns.transform_values(&:copy).merge(cols))
     end
     CAFrame.new(cols.transform_values { |col| spread_to_rows(col) },
-                axis_name: @frame.axis_name, index: @frame.index)
+                axis_name: @frame.axis_name, index: @frame.index&.copy)
   end
 
   # A per-group result (one entry per group along axis 0) laid back over the
@@ -1377,6 +1400,10 @@ class GroupedFrame
   # A column's group reduction. An N-D column is reduced along the rows, so
   # each group keeps the trailing shape: a profile column (N, L) gives (G, L).
   private def group_reduce(col, reduction, *args, **keywords)
+    if %i[first last].include?(reduction) && col.ndim == 1 && args.empty? && keywords.empty? &&
+       col.face? && !col.__send__(:holds_new_values?)
+      return col[present_rows(col).group_by_category(@cat).public_send(reduction)].copy
+    end
     it = col.group_by_category(@cat)
     if col.ndim > 1 && !keywords.key?(:axis)
       it.public_send(reduction, *args, axis: 0, **keywords)
@@ -1428,7 +1455,7 @@ class GroupedFrame
   end
 
   private def each_group_slice(in_name)
-    col = @frame[in_name]
+    col = @frame.__send__(:named_column, in_name, "aggregate")
     ngroup.times do |k|
       yield col[group_address(k), *([nil] * (col.ndim - 1))]
     end

data/lib/carray/frame/io.rb

@@ -231,7 +231,7 @@ class CAFrame
     map = types == :infer ? { default: :infer } : types
     return types unless map.is_a?(Hash)
     frame.column_names.each do |name|
-      given = [name, name.to_sym].find { |k| map.key?(k) }
+      given = map.keys.find { |k| k == name || k == name.to_sym || (k.is_a?(Array) && k.include?(name)) }
       next unless (given ? map[given] : map[:default]) == :infer
       map = map.merge(name => :string) if blank_value_in?(frame[name])
     end
@@ -454,6 +454,7 @@ class CAFrame
     unless precision.nil? || (precision.is_a?(Integer) && precision >= 0)
       raise ArgumentError, "to_csv: precision: is a number of decimal places, 0 or more (got #{precision.inspect})"
     end
+    CSVParser::Tokenizer.check_delimiters(sep, quote)
     default, per_column = CAFrame.send(:split_missing, missing, "to_csv")
     [default, *per_column.values].each do |text|
       next if text.nil? || text.is_a?(String)
@@ -510,7 +511,11 @@ class CAFrame
     formatted.each_with_index do |fcol, j|
       token = per_column.fetch(names[j], default)
       next if token.nil? || token.empty?        # the empty field, as without missing:
-      i = fcol.index(token)
+      # A cell in another encoding is the token too once transcoded.
+      i = fcol.index(token) || fcol.index do |text|
+        text && text.encoding != token.encoding &&
+          text.encode(token.encoding, invalid: :replace, undef: :replace) == token
+      end
       if i
         raise ArgumentError,
               "to_csv: row #{i} of #{names[j].inspect} is written as " \
@@ -757,8 +762,8 @@ class CAFrame
         # Still a float, so precision: 0 writes 3.0 and the column reads
         # back as floats.
         csv_rounded(e, precision).to_s
-      elsif precision && e.is_a?(Complex) && e.real.is_a?(Float)
-        Complex(*[e.real, e.imaginary].map { |x| csv_rounded(x, precision) }).to_s
+      elsif precision && e.is_a?(Complex) && (e.real.is_a?(Float) || e.imaginary.is_a?(Float))
+        Complex(*[e.real, e.imaginary].map { |x| x.is_a?(Float) ? csv_rounded(x, precision) : x }).to_s
       else
         e.to_s
       end
@@ -866,7 +871,7 @@ class CAFrame
     if text.empty? || text.include?(sep) || text.include?(quote) ||
        text.include?("\n") || text.include?("\r") || text.each_byte.all? { |b| b == 0x20 || b == 0x09 } ||
        (sep.size > 1 && (text + sep).index(sep) != text.size)
-      quote + text.gsub(quote, quote * 2) + quote
+      quote + text.gsub(quote) { quote * 2 } + quote
     else
       text
     end

data/lib/carray/frame/join.rb

@@ -135,13 +135,17 @@ class CAFrame
       key.__send__(:nearest_refuse_bytes, key, "join_asof: the on: key #{on.inspect}",
                    "join on it exactly with join")
     end
+    refuse_rounded_keys(lkey, rkey, "join_asof")
+    if [:round, :floor, :ceil].include?(direction)
+      rkey.__send__(:nearest_refuse_distanceless, rkey, direction, tolerance, "join_asof")
+    end
     addr = if exact.empty?
              lkey.locate_nearest_addr(rkey, direction: direction, tolerance: tolerance)
            else
              lexact = exact.map { |name| key_column(name, "join_asof") }
              rexact = rexact_names.map { |name| other.__send__(:key_column, name, "join_asof") }
              join_check_key_widths(exact, lexact, rexact, "join_asof")
-             _, lcode, rcode, k = join_codes(lexact, rexact)
+             _, lcode, rcode, k = join_codes(lexact, rexact, "join_asof")
              join_asof_by(lkey, rkey, lcode, rcode, k, direction, tolerance)
            end
     join_by_addr(other, [on, *exact], [ron, *rexact_names], addr, plan, view)
@@ -177,6 +181,7 @@ class CAFrame
       raise ArgumentError,
             "align: the reference has shape #{ref.shape.inspect}; give one key value per row of the result"
     end
+    refuse_rounded_keys(keys, ref, "align")
     addr = ref.locate_addr(keys)
     # The result's keys are the reference's values, taken as they are now
     # and shown with the key's attributes; the caller's array is left as
@@ -320,8 +325,9 @@ class CAFrame
   # so the number stays below the row count.  Returns [parts, lcode, rcode,
   # k], parts holding each column's [distinct values, left codes, right
   # codes].
-  private def join_codes(lkeys, rkeys)
+  private def join_codes(lkeys, rkeys, verb = "join")
     parts = lkeys.zip(rkeys).map do |lkey, rkey|
+      refuse_rounded_keys(lkey, rkey, verb)
       common = CArray.align_addr(lkey, rkey, join: :outer)[0]
       [common, lkey.locate_addr(common), rkey.locate_addr(common)]
     end
@@ -338,6 +344,14 @@ class CAFrame
     [parts, lcode, rcode, k]
   end
 
+  # The two sides of a key meet at one type; a value that type rounds would
+  # match another value.
+  private def refuse_rounded_keys(lkey, rkey, verb)
+    return if lkey.face? || rkey.face?
+    CAFrame.__send__(:refuse_rounded_integers, [lkey, rkey],
+                     lkey.send(:query_match_type, rkey), verb, "a key")
+  end
+
   # The rows of a :semi or :anti join: whether each row's key code occurs
   # among the other side's codes.  A row without a code (a masked key cell)
   # has no match.
@@ -412,7 +426,7 @@ class CAFrame
         hi = rk.project((start + lt).tap { |a| a[has_hi.not] = UNDEF })
         # an exact match takes its first reference; otherwise the nearer
         # neighbour, the upper one on a tie
-        upper = (hi - qk).le(qk - lo).strip_mask(false)
+        upper = lkey.__send__(:nearest_distance, hi, qk).le(lkey.__send__(:nearest_distance, qk, lo)).strip_mask(false)
         upper[has_lo.not] = true
         upper[has_hi.not] = false
         upper[hi.eq(qk).strip_mask(false)] = true
@@ -421,8 +435,7 @@ class CAFrame
     local[local.lt(0) | local.ge(size)] = UNDEF
     found = rrows.project(gstart.project(qc) + local)
     if limit
-      dist = (rkey.project(found) - lkey.project(lrows)).abs
-      found[dist > limit] = UNDEF
+      found[lkey.__send__(:nearest_beyond, rkey.project(found), lkey.project(lrows), limit)] = UNDEF
     end
     addr[lrows] = found
     addr
@@ -433,7 +446,8 @@ class CAFrame
   private def asof_searchable(key, code)
     ok = code.is_not_masked.strip_mask(false)
     ok &= key.is_not_masked.strip_mask(false) if key.has_mask?
-    ok &= key.is_nan.strip_mask(false).not if key.float?
+    nan = key.__send__(:nearest_nan_cells, key)
+    ok &= nan.strip_mask(false).not if nan
     ok
   end
 

data/lib/carray/frame/records.rb

@@ -181,7 +181,8 @@ class CAFrame
   # :cmplx128 when Complex values join them, otherwise nil (keep object).
   # Other Numerics (Rational, BigDecimal) stay object: a float column would
   # round them, and a Complex one has room for them only as floats too.  So
-  # does an Integer an int64 cannot hold: it is kept as it is, not refused.
+  # does an Integer an int64 cannot hold, and one past 2**53 beside a Float:
+  # it is kept as it is, not refused.
   INT64_RANGE = (-2**63..2**63 - 1)
   private_constant :INT64_RANGE
 
@@ -198,9 +199,10 @@ class CAFrame
 
   def self.numeric_leaf_type(values)
     return nil if values.any? { |v| v.is_a?(Integer) && !INT64_RANGE.cover?(v) }
-    if values.all? { |v| v.is_a?(Integer) }
-      :int64
-    elsif values.all? { |v| v.is_a?(Integer) || v.is_a?(Float) }
+    return :int64 if values.all? { |v| v.is_a?(Integer) }
+    # Beside a float an integer is read as one, which rounds past 2**53.
+    return nil if values.any? { |v| v.is_a?(Integer) && v.abs > 2**53 }
+    if values.all? { |v| v.is_a?(Integer) || v.is_a?(Float) }
       :float64
     elsif values.all? { |v| v.is_a?(Integer) || v.is_a?(Float) || v.is_a?(Complex) }
       :cmplx128

data/lib/carray/frame/reshape.rb

@@ -210,6 +210,24 @@ class CAFrame
   Ractor.make_shareable(SIGNIFICAND_BITS)
   private_constant :INTEGER_BITS, :SIGNIFICAND_BITS
 
+  # Integers past what +type+'s significand holds would meet as one value
+  # once read in it, so they are refused; the verb reads every other integer
+  # exactly. +type+ is the float the columns meet at, or anything else, which
+  # rounds nothing.
+  def self.refuse_rounded_integers (cols, type, verb, what)
+    digits = SIGNIFICAND_BITS[CArray.data_type_name(type)]
+    return if digits.nil?
+    cols.each do |col|
+      next if col.face? || !col.integer? || col.count_not_masked == 0
+      big = [col.min.abs, col.max.abs].max
+      next if big <= 2**digits
+      raise ArgumentError,
+            "#{verb}: #{what} holds #{big}, past 2**#{digits}, beyond which " \
+            "#{CArray.data_type_name(type)} does not hold every integer; cast them to one type first"
+    end
+  end
+  private_class_method :refuse_rounded_integers
+
   # Whether every value of data type +from+ is exactly a value of +to+, for
   # numbers and booleans: a boolean in any number, an integer in a wide
   # enough integer (a signed one never in an unsigned) or in a float whose
@@ -269,9 +287,11 @@ class CAFrame
   # melted columns and each id column is +CArray.meld+ of itself, so a write
   # to the result lands in +self+.  Number columns of different types meet
   # at a type that holds every value of each column's type (int8 and uint8
-  # at int16, int32 and float64 at float64), so a value written later reads
-  # back unchanged; a mixture no type holds (int64 and float64) raises, and
-  # so do other mixtures of types. The value columns share one trailing
+  # at int16, int32 and float64 at float64), so a value written to one of
+  # the columns later reads back unchanged. A value written to the result
+  # lands in the column's own type, as an array stored into it does: outside
+  # that type it wraps. A mixture no type holds (int64 and float64) raises,
+  # and so do other mixtures of types. The value columns share one trailing
   # shape; cast first when they do not.
   #
   # @param id [String, Array<String>] columns repeated alongside each value.
@@ -332,11 +352,11 @@ class CAFrame
     begin
       out[value_name] = CArray.meld(pieces)
     rescue ArgumentError => e
-      raise unless e.message.start_with?("promote_list:")
+      raise unless e.message.start_with?("meld:", "CAMeld parents")
       labels = vars.zip(pieces.map { |c| CArray::Inspector.type_label(c) }).to_h
       raise ArgumentError,
             "melt: value columns #{labels} do not meet as one column " \
-            "(#{e.message.delete_prefix("promote_list: ")}); cast them to one type first"
+            "(#{e.message.delete_prefix("meld: ")}); cast them to one type first"
     end
     CAFrame.new(out)
   end