rigortype 0.1.19 → 0.2.0

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

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "singleton_folding"
+require_relative "member_shape_projection"
 
 module Rigor
   module Inference
@@ -30,6 +31,10 @@ module Rigor
       module DataFolding
         module_function
 
+        # The `[]` / `to_h` / `deconstruct` / `members` / `with` projections
+        # and the reader-redefinition guard are shared with {StructFolding}.
+        extend MemberShapeProjection
+
         # @return [Rigor::Type, nil] the folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
@@ -165,81 +170,12 @@ module Rigor
           when :deconstruct then instance_deconstruct(instance)
           when :deconstruct_keys then instance_deconstruct_keys(instance, args)
           when :members then instance_members(instance)
-          when :with then instance_with(instance, args)
+          when :with
+            instance_with(instance, args) do |members, class_name|
+              Type::Combinator.data_instance_of(members: members, class_name: class_name)
+            end
           end
         end
-
-        # A `Data.define` class body (the `class Point < Data.define(:x);
-        # def x; …; end; end` subclass body, or a `Const = Data.define(:x) do
-        # def x; …; end; end` block) can redefine a member's synthesised
-        # reader. When it does, `inst.x` runs that `def`, NOT the member, so
-        # folding the read to the member type would be unsound (a downstream
-        # FP). Both named forms register the override as a real `def` node
-        # under the class name, so an entry in the project def-node table is
-        # the discriminator (the synthesised reader has no def node). The
-        # value accessors `[]` / `to_h` / `deconstruct` bypass the reader and
-        # stay foldable, so this gate is on the bare member read only.
-        def reader_overridden?(instance, method_name, scope)
-          class_name = instance.class_name
-          return false if class_name.nil? || scope.nil?
-
-          !scope.user_def_for(class_name, method_name).nil?
-        end
-
-        def instance_index(instance, args)
-          return nil unless args.size == 1
-
-          arg = args.first
-          return nil unless arg.is_a?(Type::Constant)
-
-          key = arg.value
-          case key
-          when Symbol
-            instance.members[key]
-          when Integer
-            values = instance.members.values
-            idx = key.negative? ? key + values.size : key
-            values[idx] if idx && idx >= 0 && idx < values.size
-          end
-        end
-
-        def instance_to_h(instance)
-          Type::Combinator.hash_shape_of(instance.members.dup)
-        end
-
-        def instance_deconstruct(instance)
-          Type::Combinator.tuple_of(*instance.members.values)
-        end
-
-        # `deconstruct_keys(nil)` / `deconstruct_keys([:x])` both yield a
-        # subset of the member map; the conservative, always-correct answer
-        # is the full closed member shape.
-        def instance_deconstruct_keys(instance, args)
-          return nil unless args.size <= 1
-
-          Type::Combinator.hash_shape_of(instance.members.dup)
-        end
-
-        def instance_members(instance)
-          Type::Combinator.tuple_of(*instance.member_names.map { |name| Type::Combinator.constant_of(name) })
-        end
-
-        # `Data#with(x: 9)` returns a new frozen copy with the named members
-        # overridden. Only a closed keyword `HashShape` whose keys are a
-        # subset of the members folds; anything else defers (RBS resolves
-        # `with` to `self`, returning the unchanged instance type).
-        def instance_with(instance, args)
-          return instance if args.empty?
-          return nil unless args.size == 1
-
-          shape = args.first
-          return nil unless shape.is_a?(Type::HashShape) && shape.closed?
-          return nil unless shape.optional_keys.empty?
-          return nil unless shape.pairs.keys.all? { |key| instance.members.key?(key) }
-
-          merged = instance.members.merge(shape.pairs)
-          Type::Combinator.data_instance_of(members: merged, class_name: instance.class_name)
-        end
       end
     end
   end

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

@@ -54,11 +54,10 @@ module Rigor
       # *correctness-preservingly* proved" excludes Constants whose
       # value is host-specific.
       module FileFolding
-        # File class methods that the analyzer can fold *when the
-        # fold is platform-safe to perform*. Today every entry is
-        # platform-sensitive (every one observes `File::SEPARATOR`
-        # or `File::ALT_SEPARATOR`); the gate below requires the
-        # opt-in flag for any of them to fire.
+        # File class methods the analyzer can fold when the opt-in
+        # flag is set. Currently identical to PLATFORM_DEPENDENT_METHODS
+        # — separated for a future non-platform-sensitive tier that
+        # can fold without the opt-in flag.
         FILE_PURE_CLASS_METHODS = Set[
           :basename,
           :dirname,
@@ -72,8 +71,8 @@ module Rigor
         # Methods whose result depends on host directory-separator
         # semantics (`/` on POSIX, `/` AND `\` on Windows, drive
         # letters, UNC paths). Folding these would bake the
-        # analyzer-host's platform into the inferred type. The opt-
-        # in flag below controls whether to do it anyway.
+        # analyzer-host's platform into the inferred type. The opt-in
+        # flag below controls whether to do it anyway.
         PLATFORM_DEPENDENT_METHODS = Set[
           :basename, :dirname, :extname, :join, :split, :absolute_path?
         ].freeze

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

@@ -175,24 +175,18 @@ module Rigor
           type.is_a?(Type::Constant) && type.value.is_a?(Symbol)
         end
 
-        # Element-yielding Enumerable methods covered as a v0.0.5
-        # placeholder. RBS already binds the block parameter
-        # correctly for plain `Array[T]` / `Set[T]` / `Range[T]`
-        # receivers via generic substitution; this tier exists so
-        # Tuple- and HashShape-shaped receivers reach the block
-        # body with the precise per-position element union /
-        # `Tuple[K, V]` pair rather than the projected
+        # Element-yielding Enumerable methods covered as a placeholder.
+        # RBS already binds the block parameter correctly for plain
+        # `Array[T]` / `Set[T]` / `Range[T]` receivers via generic
+        # substitution; this tier exists so Tuple- and HashShape-shaped
+        # receivers reach the block body with the precise per-position
+        # element union / `Tuple[K, V]` pair rather than the projected
         # `Array[union]` / `Hash[K, V]` widening.
         #
-        # NOTE (v0.0.5): the per-method coverage here (group_by,
-        # partition, each_slice, each_cons) is intentionally
-        # narrow. The longer-term direction is to move
-        # Enumerable-aware projections into a plugin tier modelled
-        # after PHPStan's extension API (ADR-2). The placeholders
-        # below stay until the plugin surface is in place; once it
-        # ships, this dispatcher loses these arms and the
-        # equivalent rules move into a built-in plugin loaded at
-        # boot.
+        # NOTE: `Plugin::NodeRuleWalk` (ADR-52 WD4) is now in place as
+        # the intended migration target for these Enumerable projections.
+        # The four methods (group_by, partition, each_slice, each_cons)
+        # remain here pending that migration.
         def single_element_block_params(receiver)
           element = element_type_of(receiver)
           return nil if element.nil?

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

@@ -43,14 +43,21 @@ module Rigor
         private_constant :NUMERIC_CONSTRUCTORS
 
         # `Kernel#Integer(s)` predicate-aware refinement set
-        # (v0.1.1 Track 1 slice 2b). Both `decimal-int-string` and
-        # `numeric-string` describe digit-only ASCII strings, so
-        # `Integer(s)` is total over the carrier domain and the
-        # result is `>= 0`. The default `base: 10` invocation
-        # accepts the same shape `String#to_i` does for these
-        # predicates; the `Integer(s, base)` overload is left for
-        # a later slice.
-        INTEGER_REFINEMENT_PREDICATES = Set[:decimal_int, :numeric].freeze
+        # (v0.1.1 Track 1 slice 2b). `decimal-int-string` is the
+        # only string refinement whose every inhabitant `Integer(s)`
+        # parses without remainder, so the result is a plain
+        # `Integer` — but NOT `non-negative-int`: the predicate
+        # `/\A-?\d+\z/` admits a leading sign, so `"-7"` is a valid
+        # decimal-int-string and `Integer("-7") == -7 < 0`. The
+        # narrowing is total (every inhabitant parses) but not `>= 0`,
+        # so it lands on `universal_int`. `numeric-string` is
+        # deliberately NOT in this set at all: since it was widened to
+        # the full Ruby numeric-literal grammar (floats, hex, rational,
+        # imaginary, signs), `Integer(numeric_string)` would raise for
+        # a `"1.5"` / `"2i"` inhabitant — not even total — so it falls
+        # through to RBS `Integer`. The `Integer(s, base)` overload is
+        # left for a later slice.
+        INTEGER_REFINEMENT_PREDICATES = Set[:decimal_int].freeze
         private_constant :INTEGER_REFINEMENT_PREDICATES
 
         def try_dispatch(context)
@@ -70,7 +77,7 @@ module Rigor
         # paths, tried in order:
         #
         # 1. A `Refined[String, predicate]` argument whose predicate
-        #    is a digit-only carrier narrows to `non-negative-int`
+        #    is a total-parse carrier narrows to `universal_int`
         #    (see {try_integer_from_refinement}).
         # 2. A `Constant` String or Numeric argument — optionally
         #    with a `Constant[Integer]` base — runs the actual
@@ -120,9 +127,14 @@ module Rigor
         # `Kernel#Integer(s)` over a `Refined[String, predicate]`
         # whose predicate is in {INTEGER_REFINEMENT_PREDICATES}.
         # Mirrors the `String#to_i` projection in `ShapeDispatch`
-        # (v0.1.1 slice 2a) — the result is always
-        # `non-negative-int`. Returns nil for any other arg shape
-        # so the RBS tier handles the generic `Integer(arg)` case.
+        # (v0.1.1 slice 2a) — the result is `universal_int`, NOT
+        # `non-negative-int`: a decimal-int-string admits a leading
+        # sign (`"-7"`), so the parsed Integer can be negative. The
+        # carrier stays an `IntegerRange` (rather than declining to
+        # the RBS `Nominal[Integer]`) so downstream range narrowing
+        # still has a range to intersect. Returns nil for any other
+        # arg shape so the RBS tier handles the generic `Integer(arg)`
+        # case.
         def try_integer_from_refinement(args)
           return nil unless args.size == 1
 
@@ -133,7 +145,7 @@ module Rigor
           return nil unless base.is_a?(Type::Nominal) && base.class_name == "String"
           return nil unless INTEGER_REFINEMENT_PREDICATES.include?(arg.predicate_id)
 
-          Type::Combinator.non_negative_int
+          Type::Combinator.universal_int
         end
 
         def try_array(args)

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # The member-shape projections shared by {DataFolding} and
+      # {StructFolding}. A `DataInstance` and a `StructInstance` expose the
+      # same surface — an ordered `members` map, `member_names`, and a
+      # `class_name` — so the value projections off that surface
+      # (`[]` / `to_h` / `deconstruct` / `deconstruct_keys` / `members` /
+      # `with`) and the reader-redefinition guard are identical between the
+      # two folders. Only `#with`'s carrier constructor differs
+      # (`data_instance_of` vs `struct_instance_of`), so it takes a block
+      # that builds the new instance from the merged member map.
+      #
+      # Both folders `extend` this module so the projections resolve as
+      # their own module functions (matching their `module_function` style).
+      module MemberShapeProjection
+        # A Data/Struct subclass body can redefine a member's synthesised
+        # reader (`def x`); when it does, `inst.x` runs that `def`, not the
+        # member, so folding the read would be unsound. A real `def` node
+        # under the class name is the discriminator (the synthesised reader
+        # has none), so an entry in the project def-node table gates the
+        # bare member read off.
+        def reader_overridden?(instance, method_name, scope)
+          class_name = instance.class_name
+          return false if class_name.nil? || scope.nil?
+
+          !scope.user_def_for(class_name, method_name).nil?
+        end
+
+        def instance_index(instance, args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant)
+
+          key = arg.value
+          case key
+          when Symbol
+            instance.members[key]
+          when Integer
+            values = instance.members.values
+            idx = key.negative? ? key + values.size : key
+            values[idx] if idx && idx >= 0 && idx < values.size
+          end
+        end
+
+        def instance_to_h(instance)
+          Type::Combinator.hash_shape_of(instance.members.dup)
+        end
+
+        def instance_deconstruct(instance)
+          Type::Combinator.tuple_of(*instance.members.values)
+        end
+
+        # `deconstruct_keys(nil)` / `deconstruct_keys([:x])` both yield a
+        # subset of the member map; the conservative, always-correct answer
+        # is the full closed member shape.
+        def instance_deconstruct_keys(instance, args)
+          return nil unless args.size <= 1
+
+          Type::Combinator.hash_shape_of(instance.members.dup)
+        end
+
+        def instance_members(instance)
+          Type::Combinator.tuple_of(*instance.member_names.map { |name| Type::Combinator.constant_of(name) })
+        end
+
+        # `#with(x: 9)` returns a new copy with the named members
+        # overridden. Only a closed keyword `HashShape` whose keys are a
+        # subset of the members folds; anything else defers (RBS resolves
+        # `with` to `self`, returning the unchanged instance type). The
+        # carrier constructor differs per folder, so the caller supplies it
+        # as a block taking the merged member map and the class name.
+        def instance_with(instance, args)
+          return instance if args.empty?
+          return nil unless args.size == 1
+
+          shape = args.first
+          return nil unless shape.is_a?(Type::HashShape) && shape.closed?
+          return nil unless shape.optional_keys.empty?
+          return nil unless shape.pairs.keys.all? { |key| instance.members.key?(key) }
+
+          merged = instance.members.merge(shape.pairs)
+          yield(merged, instance.class_name)
+        end
+      end
+    end
+  end
+end

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

@@ -25,9 +25,7 @@ module Rigor
       #    so without this preference, an alias-typed overload like
       #    `Array#[](::int) -> Elem` would beat the strict
       #    `Array#[](Range) -> Array[Elem]?` overload for a Range
-      #    argument. (Surfaced during v0.1.1 self-analysis; see the
-      #    "Interface-strictness on overload selection" item in
-      #    `docs/ROADMAP.md`.)
+      #    argument.
       # 3. **Pass 2 — gradual fall-back.** If no fully strict overload
       #    matches, accept the first arity-and-gradual-accept match
       #    (the v0.1.1 behaviour). Alias / Interface / Intersection

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

@@ -45,8 +45,9 @@ module Rigor
       # machinery works without duplication: `Tuple[Integer, String]`
       # dispatches as `Array[Integer | String]`, and
       # `HashShape{a: Integer}` dispatches as `Hash[Symbol, Integer]`.
-      # Tuple-aware refinements (e.g., `tuple[0]` returning the precise
-      # member) are deferred to Slice 5 phase 2.
+      # Tuple/HashShape element precision (e.g., `tuple[0]` returning
+      # the precise member) is handled by the preceding `ShapeDispatch`
+      # tier.
       #
       # Remaining limitations:
       #
@@ -107,17 +108,11 @@ module Rigor
         # @return [Rigor::Type, nil] inferred return type, or `nil`
         #   when no rule resolves (no class name, no method, dispatch
         #   on a Top/Dynamic[Top] receiver, etc.).
-        # @param scope [Rigor::Scope, nil] when supplied, enables
-        #   ADR-43 RBS-complete-ancestor resolution: a call on a
-        #   Ruby-source subclass not known to RBS, whose discovered
-        #   superclass chain reaches an allow-listed RBS-complete
-        #   ancestor (e.g. `Rigor::Plugin::Base`), resolves against
-        #   that ancestor's RBS. `nil` (the default for every caller
-        #   that does not thread a scope) keeps the legacy behaviour —
-        #   such an inherited call stays unresolved and degrades to
-        #   `Dynamic[Top]`, which is the false-positive-safe default
-        #   for the open hierarchies (`< ActionController::Base`, …)
-        #   the allow-list deliberately excludes.
+        # @param scope [Rigor::Scope, nil] when supplied, enables ADR-43
+        #   RBS-complete-ancestor resolution against
+        #   `ALLOWED_RBS_COMPLETE_ANCESTORS`. `nil` keeps inherited calls
+        #   unresolved (`Dynamic[Top]`) — the FP-safe default for open
+        #   hierarchies (`< ActionController::Base`, …).
         def try_dispatch(context)
           environment = context.environment
           return nil if environment.nil?
@@ -249,15 +244,8 @@ module Rigor
               ["Array", :instance, tuple_type_args(receiver)]
             when Type::HashShape
               ["Hash", :instance, hash_shape_type_args(receiver)]
-            when Type::DataInstance
-              # ADR-48 — project a member-instance carrier to its tagging
-              # class (or the `Data` supertype) so non-member calls
-              # (`inspect`, `==`, `frozen?`, ...) resolve through RBS
-              # rather than mis-firing undefined-method. Member reads were
-              # already folded by DataFolding above this tier.
-              [receiver.class_name || "Data", :instance, []]
-            when Type::DataClass
-              [receiver.class_name || "Data", :singleton, []]
+            when Type::DataInstance, Type::DataClass, Type::StructInstance, Type::StructClass
+              member_carrier_descriptor(receiver)
             when Type::BoundMethod
               # `BoundMethod` is a precision-bearing alias for
               # `Nominal[Method]`: it carries the
@@ -275,6 +263,20 @@ module Rigor
             end
           end
 
+          # ADR-48 — project a `Data`/`Struct` member carrier to its tagging
+          # class (or the `Data`/`Struct` supertype) so non-member calls
+          # (`inspect`, `==`, `frozen?`, ...) resolve through RBS rather than
+          # mis-firing undefined-method. Precise member reads were already
+          # folded by DataFolding / StructFolding above this tier.
+          def member_carrier_descriptor(receiver)
+            case receiver
+            when Type::DataInstance then [receiver.class_name || "Data", :instance, []]
+            when Type::DataClass then [receiver.class_name || "Data", :singleton, []]
+            when Type::StructInstance then [receiver.class_name || "Struct", :instance, []]
+            when Type::StructClass then [receiver.class_name || "Struct", :singleton, []]
+            end
+          end
+
           def tuple_type_args(tuple)
             return [] if tuple.elements.empty?
 

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

@@ -81,6 +81,7 @@ module Rigor
           sum: :tuple_sum,
           min: :tuple_min,
           max: :tuple_max,
+          minmax: :tuple_minmax_pair,
           sort: :tuple_sort,
           reverse: :tuple_reverse,
           to_a: :tuple_to_a,
@@ -99,9 +100,15 @@ module Rigor
           index: :tuple_find_index,
           find_index: :tuple_find_index,
           rindex: :tuple_rindex,
-          flatten: :tuple_flatten
+          flatten: :tuple_flatten,
+          join: :tuple_join
         }.freeze
 
+        # Byte cap on a folded `tuple.join` result — a huge tuple times a
+        # long separator must not materialise an unbounded `Constant`.
+        TUPLE_JOIN_BYTE_LIMIT = 4096
+        private_constant :TUPLE_JOIN_BYTE_LIMIT
+
         HASH_SHAPE_HANDLERS = {
           size: :hash_size,
           length: :hash_size,
@@ -573,8 +580,17 @@ module Rigor
                                                                %i[lowercase upcase] => :uppercase_string,
                                                                %i[uppercase upcase] => :refined_self,
                                                                %i[uppercase downcase] => :lowercase_string,
+                                                               # `numeric-string` is the full Ruby numeric-literal
+                                                               # grammar (since the predicate delegates to the
+                                                               # parser). `#downcase` preserves it — lowercasing a
+                                                               # literal (hex digits, `0X` / `E` prefixes) yields a
+                                                               # valid lowercase literal — but `#upcase` does NOT:
+                                                               # the rational / imaginary suffixes are lowercase-only
+                                                               # (`"1r".upcase == "1R"` is not a literal), so `upcase`
+                                                               # drops to the plain base `String` — still sound (the
+                                                               # result is a String), just no longer numeric.
                                                                %i[numeric downcase] => :refined_self,
-                                                               %i[numeric upcase] => :refined_self,
+                                                               %i[numeric upcase] => :base_string,
                                                                # Digit-only strings are case-invariant; the prefix
                                                                # letters in `0o…` / `0x…` are accepted by the
                                                                # predicate in either case so the predicate-subset
@@ -587,19 +603,19 @@ module Rigor
                                                                %i[hex_int downcase] => :refined_self,
                                                                %i[hex_int upcase] => :refined_self,
                                                                # v0.1.1 Track 1 slice 2 — `to_i` / `to_int` on a
-                                                               # known digit-only string. `decimal-int-string`
-                                                               # (`/\A\d+\z/`) and `numeric-string` (Rigor's
-                                                               # numeric-string predicate, ASCII digits) are
-                                                               # predicates over digit-only strings, so the parse
-                                                               # is total over the carrier domain and the result
-                                                               # is always `>= 0`. `non-negative-int` is the
-                                                               # tightest carrier that captures both the lower
-                                                               # bound and the integer-ness without inventing a
-                                                               # narrower carrier.
-                                                               %i[decimal_int to_i] => :non_negative_int,
-                                                               %i[decimal_int to_int] => :non_negative_int,
-                                                               %i[numeric to_i] => :non_negative_int,
-                                                               %i[numeric to_int] => :non_negative_int
+                                                               # `decimal-int-string` parses to an `Integer`. The
+                                                               # carrier is `universal_int`, NOT `non-negative-int`:
+                                                               # the predicate `/\A-?\d+\z/` admits a leading sign, so
+                                                               # `"-7"` is a valid decimal-int-string and
+                                                               # `"-7".to_i == -7 < 0`. `String#to_i` is total (never
+                                                               # raises), so the projection is sound — just signed.
+                                                               # `numeric-string` is deliberately NOT projected to
+                                                               # `to_i` at all: it now spans the full numeric-literal
+                                                               # grammar, so a `"1.5"` / `"2i"` inhabitant has a
+                                                               # fractional or non-Integer parse — it falls through to
+                                                               # the RBS `Integer`.
+                                                               %i[decimal_int to_i] => :universal_int,
+                                                               %i[decimal_int to_int] => :universal_int
                                                              })
           private_constant :REFINED_STRING_PROJECTIONS
 
@@ -624,6 +640,8 @@ module Rigor
             when :uppercase_string then Type::Combinator.uppercase_string
             when :lowercase_string then Type::Combinator.lowercase_string
             when :non_negative_int then Type::Combinator.non_negative_int
+            when :universal_int then Type::Combinator.universal_int
+            when :base_string then refined.base
             end
           end
 
@@ -791,6 +809,37 @@ module Rigor
             Type::Combinator.constant_of(values.sum)
           end
 
+          # `tuple.join(sep = "")` — fold to the joined `Constant[String]`
+          # when every element is a `Constant` (its `to_s` is deterministic
+          # for the scalar value classes) and the separator is absent or a
+          # `Constant[String]`. Capped at `TUPLE_JOIN_BYTE_LIMIT`.
+          def tuple_join(tuple, _method_name, args)
+            sep = tuple_join_separator(args)
+            return nil if sep.nil?
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            result = values.join(sep)
+            return nil if result.bytesize > TUPLE_JOIN_BYTE_LIMIT
+
+            Type::Combinator.constant_of(result)
+          rescue StandardError
+            nil
+          end
+
+          # The join separator: `""` for the no-arg form, the value of a
+          # single `Constant[String]` arg, or `nil` to decline.
+          def tuple_join_separator(args)
+            return "" if args.empty?
+            return nil unless args.size == 1
+
+            arg = args.first
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+
+            arg.value
+          end
+
           # `tuple.min` / `tuple.max` — fold when every element is
           # a `Constant` whose values share a Ruby-comparable
           # domain. Empty tuples fold to `Constant[nil]`.
@@ -815,6 +864,32 @@ module Rigor
             nil
           end
 
+          # `tuple.minmax` — the `[min, max]` pair as a 2-slot
+          # `Tuple[Constant[min], Constant[max]]`, mirroring the
+          # `Range#minmax` fold. Every element must be a `Constant`
+          # and the values must Ruby-compare; an empty tuple folds to
+          # `Tuple[nil, nil]` (Ruby's `[].minmax`), incomparable
+          # mixed-class values decline.
+          def tuple_minmax_pair(tuple, _method_name, args)
+            return nil unless args.empty?
+
+            if tuple.elements.empty?
+              nil_const = Type::Combinator.constant_of(nil)
+              return Type::Combinator.tuple_of(nil_const, nil_const)
+            end
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            low, high = values.minmax
+            Type::Combinator.tuple_of(
+              Type::Combinator.constant_of(low),
+              Type::Combinator.constant_of(high)
+            )
+          rescue StandardError
+            nil
+          end
+
           # `tuple.sort` — every element must be a `Constant` and
           # the values must Ruby-compare. The result is a Tuple
           # with the same elements in sorted order. Comparison