rigortype 0.1.18 → 0.2.0

data/lib/rigor/inference/hkt_body.rb

@@ -7,18 +7,15 @@ module Rigor
     # piece of a Rigor-side type expression that the reducer
     # ({HktReducer}) walks against a concrete argument list.
     #
-    # Slice 2a ships a programmatic constructor surface only:
-    # plugin and Rigor-bundled overlay authors build a body
-    # tree by hand using these node types. The string-grammar
-    # parser that reads `Definition#body` (the raw String slot
-    # already populated by Slice 1's `HktDirectives.parse_define`)
-    # into a tree is Slice 2b's deliverable; until it ships, the
-    # `body` String stays opaque and `body_tree` is the
-    # evaluable form.
+    # Slice 2a ships a programmatic constructor surface; plugin
+    # and Rigor-bundled overlay authors may build a body tree
+    # by hand using these node types. The string-grammar parser
+    # (`HktBodyParser`, Slice 2b, shipped) reads `Definition#body`
+    # (populated by Slice 1's `HktDirectives.parse_define`) into
+    # this node tree; `body_tree` is the evaluable form.
     #
-    # The five node types cover the JSON.parse and dry-monads
-    # use cases ADR-20 § Implementation slicing names as
-    # near-term adopters:
+    # The nine node types cover JSON.parse, dry-monads, and the
+    # ADR-20 § D3 conditional / membership forms (shipped):
     #
     # - {TypeLeaf}    — wraps a fully-built `Rigor::Type`
     #   (use for atoms like `nil`, `Constant<true>`,

data/lib/rigor/inference/hkt_body_parser.rb

@@ -11,29 +11,27 @@ module Rigor
     # `%a{rigor:v1:hkt_define}` payloads) into the `HktBody`
     # node tree the Slice 2a reducer evaluates against.
     #
-    # The minimum-viable grammar covered here is the
-    # union-of-atoms-and-parameterised-forms subset of ADR-20
-    # § D3 — sufficient for `JSON.parse`'s `json::value`
-    # recursive sum and for any other recursive-data-shape
-    # signatures (Lisp value trees, dry-types refinements
-    # without conditionals). The conditional / indexed-access
-    # forms (`E <: T ? A : B`, `E in [k1, k2]`) drafted in D3
-    # remain a follow-up slice — bodies that contain `?`
-    # raise `ParseError` and the calling directive parser
-    # drops the body_tree (the body String remains stored and
-    # the reducer falls back to `app.bound`).
+    # The grammar implements the full ADR-20 § D3 subset:
+    # union-of-atoms/parameterised-forms for `JSON.parse`'s
+    # `json::value` recursive sum, plus the conditional and
+    # membership forms shipped in subsequent slices. Indexed-access
+    # forms remain deferred (no concrete demand yet).
     #
-    # ## Grammar (slice 2b)
+    # ## Grammar
     #
     #     body         := union
     #     union        := type_expr ("|" type_expr)*
     #     type_expr    := atom | nominal_app | app_ref | param
+    #                   | conditional
     #     atom         := "nil" | "true" | "false" | "bool" | "untyped"
     #     param        := UCNAME   (when UCNAME ∈ params)
     #     nominal_app  := class_name ("[" type_expr ("," type_expr)* "]")?
     #     class_name   := "::"? UCNAME ("::" UCNAME)*
     #     app_ref      := "App" "[" uri "," type_expr ("," type_expr)* "]"
     #     uri          := IDENT ("::" IDENT)+
+    #     conditional  := "(" test "?" union ":" union ")"
+    #     test         := type_expr ("<:" | "==") type_expr
+    #                   | type_expr "in" "[" type_expr ("," type_expr)* "]"
     #     UCNAME       := /[A-Z]\w*/
     #     IDENT        := /[a-z_]\w*/
     #

data/lib/rigor/inference/hkt_registry.rb

@@ -10,12 +10,12 @@ module Rigor
     # `%a{rigor:v1:hkt_define: ...}` annotations in shipped
     # `.rbs` files.
     #
-    # Slice 1 keeps the registry **opaque**: it stores the
-    # registration metadata (arity, variance, bound) and the
-    # un-evaluated definition body (a raw String — Slice 2
-    # introduces the conditional / indexed-access evaluator that
-    # parses the body and reduces `Type::App` instances against
-    # it). The carrier never needs to read from the registry
+    # The registry stores registration metadata (arity, variance,
+    # bound) and the definition body as both a raw String and an
+    # evaluable `HktBody` node tree. `HktReducer` (Slice 2a) and
+    # `HktBodyParser` (Slice 2b) are both shipped and reduce
+    # `Type::App` instances against the definition. The carrier
+    # never needs to read from the registry
     # because Slice 1's `Type::App` carries its `bound` directly;
     # the registry exists at this slice solely so the parser
     # round-trip and downstream slices have a stable target API.
@@ -65,16 +65,15 @@ module Rigor
       # definition.
       #
       # `body` is the raw String payload from the `%a{...}`
-      # annotation (Slice 1's parser populates it). It stays
-      # opaque until Slice 2b's body-string parser lands.
+      # annotation (Slice 1's parser populates it); parsed into
+      # `body_tree` by `HktBodyParser` (Slice 2b, shipped).
       #
-      # `body_tree` is the optional evaluable form: a
+      # `body_tree` is the evaluable form: a
       # `Rigor::Inference::HktBody::*` node tree the Slice 2a
       # reducer walks against the application's concrete
       # arguments. Plugin and Rigor-bundled overlay authors
       # construct it programmatically through
-      # {with_body_tree}; the Slice 2b string parser will set
-      # it from `body` once it ships. The reducer treats a
+      # {.definition_with_body_tree}. The reducer treats a
       # `nil` `body_tree` as "definition not yet evaluable"
       # and returns the registered bound.
       Definition = Data.define(:uri, :params, :body, :body_tree, :source_path, :source_line) do

data/lib/rigor/inference/macro_block_self_type.rb

@@ -17,7 +17,7 @@ module Rigor
     #   `MyApp.get(...)` call);
     # - the underlying class `X` equals or inherits from the
     #   entry's `receiver_constraint`;
-    # - the call's method name is in the entry's `verbs`.
+    # - the call's method name is in the entry's `method_names`.
     #
     # On a match the helper returns the **instance** type of
     # the receiver class (`Nominal[X]`) — the narrowed
@@ -55,7 +55,7 @@ module Rigor
         # replaces the per-call plugins × block_as_methods linear scan.
         # Entries arrive in (plugin registration, declaration) order, so
         # the first ancestry match below is the same entry the previous
-        # walk returned; the verb membership the old `matches?` checked
+        # walk returned; the method-name membership the old `matches?` checked
         # is guaranteed by the table key.
         entries = registry.contribution_index.block_entries_for(call_node.name)
         entries.each do |entry|

data/lib/rigor/inference/method_dispatcher/array_to_h_folding.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Array#to_h { |x| [k, v] }` (and the no-block-pair tuple form's
+      # block sibling) return-type fold.
+      #
+      # `Enumerable#to_h` with a block maps every element to a
+      # `[key, value]` pair and collects them into a Hash. When the
+      # block's inferred return type is a recognizable 2-element
+      # `Tuple` (`[K, V]`), this tier projects the pair into a
+      # `Hash[K, V]` nominal whose key/value parameters are the
+      # widened pair types. Without this fold the call hits the RBS
+      # generic and the block's `[K, V]` return is dropped, typing as
+      # `Hash[Dynamic[top], Dynamic[top]]`.
+      #
+      # Value-pinned constants in the pair (`Constant[2]`) are widened
+      # to their nominal (`Integer`) for the Hash parameters: the built
+      # hash holds many keys, so pinning the parameter to a single
+      # element's literal would be unsound for the aggregate. The same
+      # widening the loop-body fixpoint applies (`Combinator#
+      # widen_value_pinned`) is reused.
+      #
+      # Declines (returns `nil`, leaving today's RBS answer) when:
+      #
+      # - there is no block at the call site,
+      # - the block return type is not a 2-element `Tuple`, or
+      # - the receiver is not an Array-shaped carrier (`Tuple` or
+      #   `Array` nominal). Hash receivers keep their existing
+      #   `ShapeDispatch#hash_to_h` identity fold.
+      module ArrayToHFolding
+        module_function
+
+        def try_dispatch(context)
+          return nil unless context.method_name == :to_h
+
+          block_type = context.block_type
+          return nil unless block_type.is_a?(Type::Tuple)
+          return nil unless block_type.elements.size == 2
+          return nil unless array_shaped?(context.receiver)
+
+          key = Type::Combinator.widen_value_pinned(block_type.elements[0])
+          value = Type::Combinator.widen_value_pinned(block_type.elements[1])
+          Type::Combinator.nominal_of("Hash", type_args: [key, value])
+        end
+
+        def array_shaped?(receiver)
+          case receiver
+          when Type::Tuple then true
+          when Type::Nominal then receiver.class_name == "Array"
+          else false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/call_context.rb

@@ -42,10 +42,7 @@ module Rigor
         #
         # This is the single place the call-context field list is
         # enumerated — the whole point of the value object is to absorb
-        # the wide keyword list the tiers used to each redeclare. The
-        # ParameterLists disable here retires the per-tier disables (the
-        # `RbsDispatch` quartet-plus signatures) rather than adding to
-        # them.
+        # the wide keyword list the tiers used to each redeclare.
         def self.build(receiver:, method_name:, args:, # rubocop:disable Metrics/ParameterLists
                        block_type: nil, environment: nil, call_node: nil,
                        scope: nil, self_type_override: nil, public_only: false)

data/lib/rigor/inference/method_dispatcher/constant_folding.rb

@@ -40,7 +40,7 @@ module Rigor
       #   receiver/argument combination.
       #
       # Anything else returns `nil`, signalling "no rule matched" so the
-      # caller (`ExpressionTyper`) falls back to `Dynamic[Top]` and records a
+      # caller (`MethodDispatcher`) falls back to `Dynamic[Top]` and records a
       # fail-soft event. Slice 4 (RBS-backed) layers another dispatch tier
       # behind this rule book, but the constant-folding semantics defined
       # here MUST NOT regress: any value reachable by literal arithmetic at
@@ -51,7 +51,7 @@ module Rigor
         NUMERIC_BINARY = Set[
           :+, :-, :*, :/, :%, :**, :&, :|, :^, :<<, :>>,
           :<, :<=, :>, :>=, :==, :!=, :<=>,
-          :gcd, :lcm, :fdiv
+          :gcd, :lcm, :fdiv, :quo, :ceildiv, :[]
         ].freeze
         STRING_BINARY  = Set[
           :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
@@ -60,12 +60,31 @@ module Rigor
           :match?, :index, :rindex, :center, :ljust, :rjust,
           # 1-arg pure transforms/queries whose output never exceeds the
           # input: `delete`/`squeeze` shrink the string, `count` → Integer.
-          :delete, :count, :squeeze
+          :delete, :count, :squeeze,
+          # ASCII / Unicode-case-fold comparison — deterministic, no
+          # locale read: `casecmp` → -1/0/1, `casecmp?` → bool/nil.
+          :casecmp, :casecmp?
         ].freeze
         SYMBOL_BINARY  = Set[:==, :!=, :<=>, :<, :<=, :>, :>=].freeze
         BOOL_BINARY    = Set[:&, :|, :^, :==, :!=, :===].freeze
         NIL_BINARY     = Set[:==, :!=].freeze
-        RATIONAL_BINARY = Set[:div, :modulo, :%, :remainder, :fdiv].freeze
+        # Rational arithmetic / ordering are exact and pure. Division
+        # (`/`) and `**` may return a `Float`/`Complex` for some operands,
+        # all of which are foldable `Constant` value classes. `==` / `!=`
+        # are deliberately EXCLUDED: `Rational#==` (`nurat_eqeq_p`) routes
+        # through `rb_funcall(:==)` on the operands — user-redefinable —
+        # so the catalog classifies it `:dispatch` and the equality stays
+        # the RBS `bool`. (The set would otherwise bypass that gate.)
+        RATIONAL_BINARY = Set[
+          :+, :-, :*, :/, :**, :<=>, :<, :<=, :>, :>=,
+          :div, :modulo, :%, :remainder, :fdiv, :quo
+        ].freeze
+        # Complex arithmetic. `ops_for` gains a `Complex` branch so these
+        # reach the binary fold path (Complex was previously unary-only).
+        # `/` and `**` stay foldable (Complex result). `==` / `!=` are
+        # excluded for the same reason as Rational (`nucomp_eqeq_p`
+        # delegates to operand `==`); ordering is undefined for Complex.
+        COMPLEX_BINARY = Set[:+, :-, :*, :/, :**].freeze
 
         # v0.0.3 C — pure unary catalogue. Each method must:
         # - take zero arguments,
@@ -83,20 +102,30 @@ module Rigor
         # user-defined `def is_odd(n) = n.odd?` so
         # `Parity.new.is_odd(3)` types as `Constant[true]`
         # rather than the RBS-widened `bool`.
+        # NOTE: `:hash` is deliberately NOT in any of these sets.
+        # `Object#hash` (and the `String`/`Symbol`/`Integer`/`Float`
+        # overrides) is salted with a per-process SipHash seed, so
+        # `"abc".hash` returns a different Integer in every Ruby
+        # process. Folding it to a `Constant` would bake one process's
+        # value into the type (and the on-disk cache), making the
+        # result non-deterministic across runs — a violation of the
+        # purity contract this catalogue rests on. A literal's `.hash`
+        # therefore stays the RBS-widened `Integer`. The deterministic
+        # siblings `:inspect` / `:to_s` remain folded.
         INTEGER_UNARY = Set[
           :odd?, :even?, :zero?, :positive?, :negative?,
           :succ, :pred, :next, :abs, :magnitude,
           :bit_length, :to_s, :to_i, :to_int, :to_f,
           :floor, :ceil, :round, :truncate, :chr,
-          :inspect, :hash, :-@, :+@, :~
+          :inspect, :-@, :+@, :~, :to_r, :to_c
         ].freeze
         FLOAT_UNARY = Set[
           :zero?, :positive?, :negative?,
           :nan?, :finite?, :infinite?,
           :abs, :magnitude, :floor, :ceil, :round, :truncate,
           :next_float, :prev_float,
-          :to_s, :to_i, :to_int, :to_f,
-          :inspect, :hash, :-@, :+@
+          :to_s, :to_i, :to_int, :to_f, :to_r, :rationalize,
+          :inspect, :-@, :+@
         ].freeze
         STRING_UNARY = Set[
           :upcase, :downcase, :capitalize, :swapcase,
@@ -104,20 +133,29 @@ module Rigor
           :empty?, :strip, :lstrip, :rstrip, :chomp, :chop, :squeeze,
           :to_s, :to_str, :to_sym, :intern,
           :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
-          :inspect, :hash
+          :sum, :inspect
         ].freeze
         SYMBOL_UNARY = Set[
           :to_s, :to_sym, :to_proc, :length, :size,
           :empty?, :upcase, :downcase, :capitalize,
-          :swapcase, :inspect, :hash
+          :swapcase, :succ, :next, :inspect
         ].freeze
-        BOOL_UNARY = Set[:!, :to_s, :inspect, :hash, :&, :|, :^].freeze
-        NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect, :hash].freeze
+        BOOL_UNARY = Set[:!, :to_s, :inspect, :&, :|, :^].freeze
+        NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect].freeze
         RATIONAL_UNARY = Set[
           :zero?, :integer?, :real, :abs2,
-          :conj, :conjugate, :nonzero?
+          :conj, :conjugate, :nonzero?,
+          :numerator, :denominator, :abs, :magnitude,
+          :to_f, :to_i, :to_int, :to_r, :rationalize,
+          :floor, :ceil, :round, :truncate,
+          :-@, :+@
+        ].freeze
+        COMPLEX_UNARY = Set[
+          :zero?, :nonzero?,
+          :abs, :magnitude, :abs2, :arg, :angle, :phase,
+          :conjugate, :conj, :real, :imaginary, :imag,
+          :to_c, :-@, :+@
         ].freeze
-        COMPLEX_UNARY = Set[:zero?, :nonzero?].freeze
 
         STRING_FOLD_BYTE_LIMIT = 4096
 
@@ -226,13 +264,54 @@ module Rigor
           case type
           when Type::Constant then [type.value]
           when Type::Union
-            return nil unless type.members.all?(Type::Constant)
-
-            type.members.map(&:value)
+            return type.members.map(&:value) if type.members.all?(Type::Constant)
+
+            # A union that mixes `Constant<Integer>` and `IntegerRange`
+            # members (e.g. an accumulator's running fixpoint assumption
+            # `1 | int<1, 6>`) folds as the bounding interval. The
+            # range-arithmetic path (`try_fold_binary_range`) then keeps
+            # the result an `IntegerRange` instead of bailing to Dynamic.
+            union_integer_bounds(type)
           when Type::IntegerRange then type
           end
         end
 
+        # Returns the bounding `IntegerRange` over a union whose members
+        # are each an Integer `Constant` or an `IntegerRange`; `nil`
+        # otherwise (a Float constant or any non-numeric member declines,
+        # so precision is never silently lost).
+        def union_integer_bounds(union)
+          lowers = []
+          uppers = []
+          union.members.each do |member|
+            case member
+            when Type::Constant
+              return nil unless member.value.is_a?(Integer)
+
+              lowers << member.value
+              uppers << member.value
+            when Type::IntegerRange
+              lowers << member.lower
+              uppers << member.upper
+            else
+              return nil
+            end
+          end
+          # `IntegerRange#lower`/`#upper` surface an unbounded edge as
+          # `±Float::INFINITY`; `integer_range` wants the `±∞` *sentinel*,
+          # so map the extremum back.
+          Type::Combinator.integer_range(infinity_to_sentinel(lowers.min),
+                                         infinity_to_sentinel(uppers.max))
+        end
+
+        def infinity_to_sentinel(bound)
+          case bound
+          when -Float::INFINITY then Type::IntegerRange::NEG_INFINITY
+          when Float::INFINITY then Type::IntegerRange::POS_INFINITY
+          else bound
+          end
+        end
+
         def try_fold_unary(set, method_name)
           case set
           when Array              then try_fold_unary_set(set, method_name)
@@ -345,9 +424,15 @@ module Rigor
         # Only fires on a single-receiver Range with finite integer
         # endpoints; mixed unions fall through so the existing
         # union-of-Constants path keeps the rest of the arms.
-        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax].freeze
+        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax,
+                                 :sum].freeze
+        # 1-arg head/tail projections on a `Constant<Range>`. `first(n)` /
+        # `take(n)` return the first `n` elements, `last(n)` the final `n` —
+        # each lifts to a per-position `Tuple[Constant[Integer]…]`. The
+        # no-arg `first` / `last` stay on the unary path (single Integer).
+        RANGE_FOLD_BINARY_METHODS = Set[:first, :last, :take].freeze
         RANGE_TO_A_LIMIT = 16
-        private_constant :RANGE_FOLD_METHODS, :RANGE_TO_A_LIMIT
+        private_constant :RANGE_FOLD_METHODS, :RANGE_FOLD_BINARY_METHODS, :RANGE_TO_A_LIMIT
 
         def try_fold_range_constant_unary(receiver_values, method_name)
           return nil unless RANGE_FOLD_METHODS.include?(method_name)
@@ -367,6 +452,11 @@ module Rigor
           when :last, :max then range_endpoint_constant(range, :last)
           when :count, :size, :length then Type::Combinator.constant_of(range.to_a.size)
           when :minmax then range_minmax_tuple(range)
+          # `range.sum` is closed-form (Gauss) for an integer range, so a
+          # huge range still costs O(1) and yields a single Integer — no
+          # materialisation, no cap needed. Endless ranges are already
+          # excluded by the Integer-endpoint guard in the caller.
+          when :sum then Type::Combinator.constant_of(range.sum)
           end
         end
 
@@ -400,10 +490,46 @@ module Rigor
           )
         end
 
+        # `(1..10).first(3)` / `.take(3)` / `.last(3)` — the 1-arg head /
+        # tail forms. `first`/`last` already fold no-arg through the unary
+        # path; this is the n-arg sibling, mirroring the Tuple carrier's
+        # `first(n)`/`take(n)` handlers. Lifts to `Tuple[Constant…]`.
+        def try_fold_range_constant_binary(receiver_values, method_name, arg_values)
+          return nil unless RANGE_FOLD_BINARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          range = receiver_values.first
+          return nil unless range.is_a?(Range)
+          return nil unless range.begin.is_a?(Integer) && range.end.is_a?(Integer)
+
+          range_take_tuple(range, method_name, arg_values.first)
+        rescue StandardError
+          nil
+        end
+
+        def range_take_tuple(range, method_name, count)
+          return nil unless count.is_a?(Integer) && !count.negative?
+          # `first(n)`/`last(n)`/`take(n)` materialise at most `min(n, size)`
+          # elements; cap that count so a huge `n` (or range) never blows up
+          # the Constant. `Range#size` is O(1) for integer endpoints.
+          return nil if [count, range.size].min > RANGE_TO_A_LIMIT
+
+          values = method_name == :last ? range.last(count) : range.first(count)
+          return Type::Combinator.tuple_of if values.empty?
+
+          Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
+        end
+
         def try_fold_binary_set(receiver_values, method_name, arg_values)
+          range_lift = try_fold_range_constant_binary(receiver_values, method_name, arg_values)
+          return range_lift if range_lift
+
           string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return string_lift if string_lift
 
+          integer_lift = try_fold_integer_array_binary(receiver_values, method_name, arg_values)
+          return integer_lift if integer_lift
+
           pathname_lift = try_fold_pathname_binary(receiver_values, method_name, arg_values)
           return pathname_lift if pathname_lift
 
@@ -415,15 +541,20 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values + arg_values)
         end
-        # v0.0.7 — `Constant<String>#chars` / `bytes` / `lines` /
-        # `split` (no-arg) return a Ruby Array of foldable
+        # v0.0.7 — `Constant<String>#chars` / `bytes` / `codepoints` /
+        # `lines` / `split` (no-arg) return a Ruby Array of foldable
         # scalars; `foldable_constant_value?` rejects Array
         # results, so the standard unary path declines. Lift the
         # Array to a per-position `Tuple[Constant…]` directly,
         # capped at `STRING_ARRAY_LIFT_LIMIT` to keep the result
-        # bounded for long strings.
-        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :lines, :split].freeze
-        STRING_ARRAY_BINARY_METHODS = Set[:split, :scan].freeze
+        # bounded for long strings. (`codepoints` yields per-character
+        # Integer codepoints, the sibling of the byte-valued `bytes`.)
+        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :codepoints, :lines, :split].freeze
+        # `partition` / `rpartition` always return a fixed 3-element
+        # `[head, separator, tail]` Array whose members are substrings of
+        # the receiver (bounded by the input), so they lift to a precise
+        # 3-slot `Tuple[Constant…]`.
+        STRING_ARRAY_BINARY_METHODS = Set[:split, :scan, :partition, :rpartition].freeze
         STRING_ARRAY_LIFT_LIMIT = 32
         private_constant :STRING_ARRAY_UNARY_METHODS,
                          :STRING_ARRAY_BINARY_METHODS,
@@ -453,6 +584,14 @@ module Rigor
         INTEGER_ARRAY_UNARY_METHODS = Set[:digits].freeze
         private_constant :INTEGER_ARRAY_UNARY_METHODS
 
+        # 1-arg Integer methods that return an Array of foldable
+        # Integers: `digits(base)` (base-n place values; raises on a
+        # negative receiver or base < 2 → declines) and `gcdlcm(other)`
+        # (the fixed `[gcd, lcm]` pair). Both are pure arithmetic; the
+        # result lifts to a `Tuple[Constant[Integer]…]`.
+        INTEGER_ARRAY_BINARY_METHODS = Set[:digits, :gcdlcm].freeze
+        private_constant :INTEGER_ARRAY_BINARY_METHODS
+
         # v0.0.7 — `Constant<Pathname>` delegates to a curated set
         # of pure path-manipulation methods. Pathname is immutable
         # in Ruby (per its docstring) and the catalog classifies
@@ -572,6 +711,25 @@ module Rigor
           nil
         end
 
+        # `Constant<Integer>#digits(base)` / `#gcdlcm(other)` — the
+        # 1-arg Array-returning Integer methods. `digits(base)` declines
+        # on a negative receiver (the unary path's guard); other domain
+        # errors (base < 2) raise and are rescued. `gcdlcm` is total over
+        # Integer args.
+        def try_fold_integer_array_binary(receiver_values, method_name, arg_values)
+          return nil unless INTEGER_ARRAY_BINARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          receiver = receiver_values.first
+          arg = arg_values.first
+          return nil unless receiver.is_a?(Integer) && arg.is_a?(Integer)
+          return nil if method_name == :digits && receiver.negative?
+
+          lift_array_result(receiver.public_send(method_name, arg))
+        rescue StandardError
+          nil
+        end
+
         # `Constant<Complex>#rect` / `#rectangular` — lifts `[real, imaginary]`
         # to `Tuple[Constant[re], Constant[im]]`. Both components are always
         # numeric (Integer or Float for literal complexes), so they satisfy
@@ -1265,17 +1423,16 @@ module Rigor
           end
         end
 
-        # `String#reverse` / `#swapcase` etc. produce a
-        # string the same size as the receiver; only the
-        # already-handled binary `:+` / `:*` paths can
-        # explode the output. No unary string method
-        # currently in the catalogue grows beyond the input
-        # size, so this hook is a no-op today — kept as a
-        # placeholder so future additions (e.g. `:succ` on
-        # very long strings) can be guarded without
-        # restructuring.
-        def string_unary_blow_up?(_receiver_value, _method_name)
-          false
+        # `String#reverse` / `#swapcase` / `#succ` etc. produce a string
+        # at least as large as the receiver. The binary `:+` / `:*` paths
+        # have their own `string_blow_up?` output guard; this is the unary
+        # analogue — decline to fold a unary String op whose receiver is
+        # already at or beyond `STRING_FOLD_BYTE_LIMIT`, since the folded
+        # output would be just as large and constant-materialising it buys
+        # no precision worth the bytes. Non-String receivers never blow up
+        # through a unary op, so they pass.
+        def string_unary_blow_up?(receiver_value, _method_name)
+          receiver_value.is_a?(String) && receiver_value.bytesize >= STRING_FOLD_BYTE_LIMIT
         end
 
         # Scalar / String / Symbol values fold; everything
@@ -1294,7 +1451,24 @@ module Rigor
         private_constant :FOLDABLE_CONSTANT_CLASSES
 
         def foldable_constant_value?(value)
-          FOLDABLE_CONSTANT_CLASSES.any? { |klass| value.is_a?(klass) }
+          return false unless FOLDABLE_CONSTANT_CLASSES.any? { |klass| value.is_a?(klass) }
+
+          # A NaN result (`0.0 / 0.0`, `Float::NAN`-propagating arithmetic,
+          # or a NaN-bearing Complex) is non-reflexive under `==`, so a
+          # `Constant[NaN]` would break the `==` / `eql?` / `hash` contract
+          # `build_constant_type` relies on for union dedup. Decline the
+          # fold and let the RBS tier answer with the widened class.
+          return false if value.is_a?(Float) && value.nan?
+          return false if value.is_a?(Complex) && complex_nan?(value)
+
+          true
+        end
+
+        # True when either component of a Complex is NaN.
+        def complex_nan?(value)
+          real = value.real
+          imag = value.imaginary
+          (real.is_a?(Float) && real.nan?) || (imag.is_a?(Float) && imag.nan?)
         end
 
         def safe?(receiver_value, method_name, arg_value)
@@ -1315,6 +1489,7 @@ module Rigor
           when true, false    then BOOL_BINARY
           when nil            then NIL_BINARY
           when Rational       then RATIONAL_BINARY
+          when Complex        then COMPLEX_BINARY
           else                     Set.new
           end
         end