rigortype 0.0.4 → 0.0.6

data/lib/rigor/inference/expression_typer.rb

@@ -500,39 +500,99 @@ module Rigor
       # rebinding is the StatementEvaluator's job (Slice 3 phase 2).
       # Without an else clause the branch's implicit value is nil, which
       # is included in the union.
+      #
+      # v0.0.6 — when the predicate folds to a `Type::Constant` whose
+      # value is Ruby-truthy (resp. Ruby-falsey), the unreachable
+      # branch is elided so the if-expression's type is the live
+      # branch alone. Statement-level branch elision lives in
+      # `StatementEvaluator#eval_if`; this handler covers the
+      # expression-position ternary form (`a ? b : c`) and any
+      # `if`/`unless` reached through `type_of`.
       def type_of_if(node)
         then_type = statements_or_nil(node.statements)
-        else_type =
-          if node.subsequent
-            type_of(node.subsequent)
-          else
-            Type::Combinator.constant_of(nil)
-          end
-        Type::Combinator.union(then_type, else_type)
+        else_type = if_else_type(node.subsequent)
+        elide_or_union(node.predicate, then_type, else_type)
       end
 
       # `unless c; t; else; e; end`. Prism uses `else_clause` here (no
-      # `elsif` chain).
+      # `elsif` chain). Branch-elision logic mirrors `type_of_if`,
+      # inverted: a truthy predicate selects the else branch.
       def type_of_unless(node)
         then_type = statements_or_nil(node.statements)
-        else_type =
-          if node.else_clause
-            type_of(node.else_clause)
-          else
-            Type::Combinator.constant_of(nil)
-          end
-        Type::Combinator.union(then_type, else_type)
+        else_type = if_else_type(node.else_clause)
+        elide_or_union(node.predicate, else_type, then_type)
+      end
+
+      def if_else_type(subsequent)
+        return Type::Combinator.constant_of(nil) if subsequent.nil?
+
+        type_of(subsequent)
+      end
+
+      # Routes the predicate's typed value through branch elision.
+      # `live_when_truthy` and `live_when_falsey` are the branch
+      # types selected by the predicate's polarity; the names
+      # match `IfNode` semantics directly and invert at the
+      # `type_of_unless` call site.
+      def elide_or_union(predicate, live_when_truthy, live_when_falsey)
+        case constant_predicate_polarity(predicate)
+        when :truthy then live_when_truthy
+        when :falsey then live_when_falsey
+        else Type::Combinator.union(live_when_truthy, live_when_falsey)
+        end
+      end
+
+      # Returns `:truthy`, `:falsey`, or `nil` for an arbitrary
+      # predicate expression. Only `Type::Constant` answers
+      # decisively — `Union[true, false]`, `Nominal[bool]`, and
+      # `Dynamic[T]` keep both branches live.
+      def constant_predicate_polarity(predicate)
+        return nil if predicate.nil?
+
+        type = type_of(predicate)
+        return nil unless type.is_a?(Type::Constant)
+
+        type.value ? :truthy : :falsey
       end
 
       def type_of_else(node)
         statements_or_nil(node.statements)
       end
 
-      # `a && b` and `a || b` short-circuit. Without a truthy/falsy
-      # narrowing model (Slice 6), the result of either side is reachable
-      # so the type is the union of the operand types.
+      # `a && b` and `a || b` short-circuit at the value level:
+      # `a && b` returns `a` when `a` is falsey, else `b`.
+      # `a || b` returns `a` when `a` is truthy,  else `b`.
+      #
+      # v0.0.6 — when the left operand folds to a `Type::Constant`,
+      # we know which side actually flows through, so the result
+      # is one operand's type instead of a union. Otherwise the
+      # union-of-both-operands fallback is preserved.
       def type_of_and_or(node)
-        Type::Combinator.union(type_of(node.left), type_of(node.right))
+        left_type = type_of(node.left)
+        polarity = constant_value_polarity(left_type)
+        return short_circuit_for(node, left_type, polarity) if polarity
+
+        Type::Combinator.union(left_type, type_of(node.right))
+      end
+
+      def short_circuit_for(node, left_type, polarity)
+        and_node = node.is_a?(Prism::AndNode)
+        if polarity == :truthy
+          and_node ? type_of(node.right) : left_type
+        else
+          and_node ? left_type : type_of(node.right)
+        end
+      end
+
+      # Returns `:truthy` / `:falsey` for a `Type::Constant`,
+      # nil otherwise. Mirrors `constant_predicate_polarity` but
+      # operates on a typed value (already-type-of'd) rather
+      # than a Prism node, so the same predicate analysis can
+      # be reused in both contexts.
+      def constant_value_polarity(type)
+        return nil unless type.is_a?(Type::Constant)
+
+        type.value ? :truthy : :falsey
       end
 
       def type_of_case(node)
@@ -701,12 +761,17 @@ module Rigor
       # when every element is a non-splat value. Splatted entries
       # (`[*xs, 1]`) preserve the Slice 4 phase 2d behavior: we union
       # the contributed element types and emit
-      # `Nominal[Array, [union]]`. An empty literal stays as the raw
-      # `Array` (no element evidence to lock either an arity or an
-      # element type).
+      # `Nominal[Array, [union]]`.
+      #
+      # v0.0.6 — the empty literal `[]` resolves to the empty
+      # `Tuple[]` carrier rather than the raw `Nominal[Array]`.
+      # Both carriers erase to RBS `Array`, but `Tuple[]` pins
+      # the literal's known arity (zero), which lets the
+      # per-element block fold concatenate across all-empty
+      # positions like `[1, 2].flat_map { |_| [] }`.
       def array_type_for(node)
         elements = node.elements
-        return Type::Combinator.nominal_of(Array) if elements.empty?
+        return Type::Combinator.tuple_of if elements.empty?
 
         if elements.any?(Prism::SplatNode)
           element_types = elements.map { |e| type_of(e) }
@@ -739,6 +804,7 @@ module Rigor
       # for the CallNode itself (the inner type_of calls already record
       # their own fallbacks for unrecognised receivers/args, so the tracer
       # captures both the immediate dispatch miss and the deeper cause).
+      # rubocop:disable Metrics/CyclomaticComplexity
       def call_type_for(node)
         receiver = call_receiver_type_for(node)
         arg_types = call_arg_types(node)
@@ -771,6 +837,18 @@ module Rigor
           return dynamic_top
         end
 
+        # v0.0.6 phase 2 — per-element block fold for Tuple
+        # receivers. When `[a, b, c].map { |x| f(x) }` and the
+        # receiver is a `Tuple` carrier with finite elements,
+        # type the block body once per position with the
+        # corresponding element bound to the block parameter
+        # and assemble the results into a `Tuple[U_1..U_n]`.
+        # This sits ahead of `MethodDispatcher.dispatch` so
+        # the RBS tier does not re-widen the answer back to
+        # `Array[union]`.
+        per_element = try_per_element_block_fold(node, receiver)
+        return per_element if per_element
+
         result = MethodDispatcher.dispatch(
           receiver_type: receiver,
           method_name: node.name,
@@ -797,6 +875,7 @@ module Rigor
 
         fallback_for(node, family: :prism)
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       # v0.0.2 #5 — re-types the body of a user-defined
       # instance method with the call site's argument types
@@ -976,6 +1055,189 @@ module Rigor
 
         block_scope.type_of(body)
       end
+
+      # v0.0.6 phase 2 — per-element block fold for Tuple
+      # receivers under `:map` / `:collect`. Walks every Tuple
+      # position, binds the block parameter to that element's
+      # type, and re-types the block body. The per-position
+      # results are assembled into `Tuple[U_1..U_n]`, strictly
+      # tighter than the RBS-projected `Array[union]`.
+      #
+      # Declines (returns nil) when the receiver is not a
+      # `Tuple` with at least one element, when the call has
+      # no `Prism::BlockNode`, when the method is outside the
+      # supported set, when block typing raises mid-loop, or
+      # when the block has no body. The decline path leaves
+      # the dispatch chain untouched.
+      PER_ELEMENT_TUPLE_METHODS = Set[
+        :map, :collect, :filter_map, :flat_map,
+        :find, :detect, :find_index, :index
+      ].freeze
+      private_constant :PER_ELEMENT_TUPLE_METHODS
+
+      # Cardinality cap for per-element block fold over
+      # finite-bound `Constant<Range>` receivers. Walking
+      # `(1..1_000_000).map { … }` element-wise would balloon
+      # block-typing cost and explode the resulting Tuple, so
+      # only short ranges expand into per-position folds.
+      # Larger ranges decline so the RBS tier widens.
+      PER_ELEMENT_RANGE_LIMIT = 8
+      private_constant :PER_ELEMENT_RANGE_LIMIT
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def try_per_element_block_fold(call_node, receiver_type)
+        return nil unless PER_ELEMENT_TUPLE_METHODS.include?(call_node.name)
+        return nil if find_family_with_args?(call_node)
+
+        element_types = per_element_elements_of(receiver_type)
+        return nil if element_types.nil? || element_types.empty?
+
+        block_node = call_node.block
+        return nil unless block_node.is_a?(Prism::BlockNode)
+
+        per_position = element_types.map do |element_type|
+          type_block_body_with_param(block_node, [element_type])
+        end
+        return nil if per_position.any?(&:nil?)
+
+        assemble_per_element_result(call_node.name, per_position, element_types)
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # Returns the per-position element types for a finite,
+      # statically-known receiver shape — or nil when the
+      # receiver does not pin a finite element list.
+      #
+      # `Tuple[A, B, …]`        → [A, B, …]
+      # `Constant<a..b>`        → [Constant[a], …, Constant[b]]
+      # everything else         → nil
+      #
+      # Note: `Type::IntegerRange` is the bounded-Integer
+      # carrier (`int<a, b>` represents "an Integer between
+      # a and b"), not a Range value. Calls like `.map` /
+      # `.find` on an `IntegerRange` receiver would resolve
+      # to `Integer#map` / `Integer#find` — neither exists —
+      # so IntegerRange does NOT participate in this fold.
+      def per_element_elements_of(receiver_type)
+        case receiver_type
+        when Type::Tuple then receiver_type.elements
+        when Type::Constant then constant_range_elements(receiver_type.value)
+        end
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def constant_range_elements(value)
+        return nil unless value.is_a?(Range)
+        return nil unless value.begin.is_a?(Integer) && value.end.is_a?(Integer)
+
+        cardinality = value.exclude_end? ? value.end - value.begin : value.end - value.begin + 1
+        return nil if cardinality <= 0 || cardinality > PER_ELEMENT_RANGE_LIMIT
+
+        value.to_a.map { |v| Type::Combinator.constant_of(v) }
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      # `index(value)` and `find_index(value)` carry a positional
+      # argument and search by `==` rather than running the block.
+      # Decline so the RBS tier owns those forms.
+      def find_family_with_args?(call_node)
+        return false unless %i[find_index index].include?(call_node.name)
+
+        args = call_node.arguments
+        !args.nil? && !args.arguments.empty?
+      end
+
+      def assemble_per_element_result(method_name, per_position, element_types)
+        case method_name
+        when :map, :collect then Type::Combinator.tuple_of(*per_position)
+        when :filter_map then assemble_filter_map_result(per_position)
+        when :flat_map then assemble_flat_map_result(per_position)
+        when :find, :detect then assemble_find_result(per_position, element_types)
+        when :find_index, :index then assemble_find_index_result(per_position)
+        end
+      end
+
+      # `filter_map` folds tightly only when every per-position
+      # result is a `Constant`: positions whose value is `nil`
+      # or `false` drop, the rest survive in declaration order.
+      # When any position is non-Constant the dispatcher
+      # declines (returns nil) so the RBS tier widens to
+      # `Array[U]`.
+      def assemble_filter_map_result(per_position)
+        return nil unless per_position.all?(Type::Constant)
+
+        kept = per_position.reject { |type| type.value.nil? || type.value == false }
+        Type::Combinator.tuple_of(*kept)
+      end
+
+      # `flat_map` flattens a single level: if the per-position
+      # result is a `Tuple`, its elements are concatenated; if
+      # it's a non-Array scalar carrier (`Constant<…>` over a
+      # non-Array literal) it contributes one element. We fold
+      # tightly only when every per-position result is one of
+      # those two recognisable shapes — `Nominal[Array[T]]`,
+      # `Union[…]`, and other opaque carriers decline so the
+      # RBS tier widens to `Array[U]`.
+      #
+      # `Type::Constant` only ever holds non-Array scalars (the
+      # carrier rejects Array literals), so a single `Constant`
+      # safely contributes itself as a single Tuple element.
+      def assemble_flat_map_result(per_position)
+        flattened = per_position.flat_map { |type| flat_map_contribution(type) }
+        return nil if flattened.nil? || flattened.any?(&:nil?)
+
+        Type::Combinator.tuple_of(*flattened)
+      end
+
+      def flat_map_contribution(type)
+        case type
+        when Type::Tuple then type.elements
+        when Type::Constant then [type]
+        else [nil]
+        end
+      end
+
+      # `find` / `detect`: returns the first receiver element
+      # whose block result is Ruby-truthy, or `nil` when no
+      # position folds to truthy.
+      #
+      # Folds tightly only when every per-position block result
+      # is a `Type::Constant` — otherwise we cannot decide which
+      # position (if any) is "the first matching one". When the
+      # first decisive truthy position is found, the answer is
+      # the corresponding receiver element. When every position
+      # folds to falsey, the answer is `Constant[nil]`.
+      def assemble_find_result(per_position, element_types)
+        return nil unless per_position.all?(Type::Constant)
+
+        first_truthy_index = per_position.index { |type| truthy_constant?(type) }
+        return Type::Combinator.constant_of(nil) if first_truthy_index.nil?
+
+        element_types[first_truthy_index]
+      end
+
+      # `find_index` / `index`: returns the index of the first
+      # truthy position, or `Constant[nil]` when nothing matches.
+      def assemble_find_index_result(per_position)
+        return nil unless per_position.all?(Type::Constant)
+
+        first_truthy_index = per_position.index { |type| truthy_constant?(type) }
+        return Type::Combinator.constant_of(nil) if first_truthy_index.nil?
+
+        Type::Combinator.constant_of(first_truthy_index)
+      end
+
+      def truthy_constant?(type)
+        type.is_a?(Type::Constant) && type.value && type.value != false
+      end
+
+      def type_block_body_with_param(block_node, expected_param_types)
+        bindings = BlockParameterBinder.new(expected_param_types: expected_param_types).bind(block_node)
+        block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
+        type_block_body(block_node, block_scope)
+      rescue StandardError
+        nil
+      end
     end
     # rubocop:enable Metrics/ClassLength
   end

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

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Block-shaped fold dispatch (v0.0.6 phase 1).
+      #
+      # Sits ahead of `RbsDispatch.try_dispatch` and folds a small
+      # set of block-taking Enumerable methods when the inferred
+      # block return type is a Ruby-truthy or Ruby-falsey
+      # `Type::Constant`. The block-parameter typing for the same
+      # methods continues to be answered by `IteratorDispatch`
+      # (this module concerns the *return* of the call, not the
+      # block-param binding).
+      #
+      # The methods covered fall in two families:
+      #
+      # - **Filter-shaped** (`select` / `filter` / `reject` /
+      #   `take_while` / `drop_while`): the block's truthiness
+      #   selects the all-or-nothing endpoints — either the
+      #   receiver's full shape (when every element is kept) or
+      #   the empty-tuple carrier (when every element is dropped).
+      # - **Predicate-shaped** (`all?` / `any?` / `none?`): the
+      #   block's truthiness combined with the receiver's
+      #   emptiness collapses the call to a `Constant[bool]` in
+      #   the cases where Ruby's actual semantics make it
+      #   unconditional. Non-empty + truthy `any?` is `true`;
+      #   non-empty + falsey `all?` is `false`; the empty-receiver
+      #   "vacuous" answers (`[].all? { false } == true`,
+      #   `[].any? { true } == false`, `[].none? { true } == true`)
+      #   are likewise honoured.
+      #
+      # The dispatcher returns `nil` for any case that cannot be
+      # decided from the (receiver-shape, method, block-truthiness)
+      # tuple — element-wise block re-evaluation against
+      # `Constant<Array>` receivers (the `map` / `filter_map` /
+      # `flat_map` precision tier) is reserved for a later slice.
+      module BlockFolding # rubocop:disable Metrics/ModuleLength
+        module_function
+
+        FILTER_KEEP_ON_TRUTHY = Set[:select, :filter, :take_while].freeze
+        FILTER_KEEP_ON_FALSEY = Set[:reject, :drop_while].freeze
+
+        PREDICATE_METHODS = Set[:all?, :any?, :none?].freeze
+
+        # Methods whose answer is `nil` when the block always
+        # returns Ruby-falsey — `find` / `detect` short-circuit
+        # to nil when nothing matches, `find_index` / `index`
+        # likewise. These methods only fold on the falsey side
+        # for now; the truthy-block side requires per-position
+        # analysis (the index of the first kept element, or the
+        # element itself, depend on the receiver's shape and on
+        # which positions actually evaluate to truthy).
+        FALSEY_BLOCK_NIL_METHODS = Set[:find, :detect, :find_index, :index].freeze
+
+        # Block-taking `count` returns the number of elements
+        # for which the block is truthy. With a Constant-falsey
+        # block the answer is unconditionally `Constant[0]`;
+        # with a Constant-truthy block on a finitely-sized
+        # receiver it is `Constant[size]`.
+        COUNT_METHOD = :count
+
+        # @param receiver    [Rigor::Type, nil]
+        # @param method_name [Symbol]
+        # @param args        [Array<Rigor::Type>]
+        # @param block_type  [Rigor::Type, nil] inferred return type of
+        #   the call's block. `nil` means "no block at the call site"
+        #   and disqualifies every rule here.
+        # @return [Rigor::Type, nil]
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def try_fold(receiver:, method_name:, args:, block_type:)
+          return nil if receiver.nil? || block_type.nil?
+
+          truthiness = constant_truthiness(block_type)
+          return nil if truthiness.nil?
+
+          if PREDICATE_METHODS.include?(method_name)
+            fold_predicate(receiver, method_name, truthiness)
+          elsif filter_method?(method_name)
+            fold_filter(receiver, method_name, truthiness)
+          elsif FALSEY_BLOCK_NIL_METHODS.include?(method_name)
+            fold_falsey_nil_short_circuit(method_name, truthiness, args)
+          elsif method_name == COUNT_METHOD
+            fold_count(receiver, truthiness, args)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def filter_method?(method_name)
+          FILTER_KEEP_ON_TRUTHY.include?(method_name) ||
+            FILTER_KEEP_ON_FALSEY.include?(method_name)
+        end
+
+        # Maps the block return type to `:truthy`, `:falsey`, or
+        # `nil` (inconclusive). Only `Type::Constant` answers
+        # decisively — `Union[true, false]`, `Nominal[…]`, or
+        # `Dynamic[T]` keep the dispatcher silent so the RBS
+        # tier still owns the call.
+        def constant_truthiness(block_type)
+          return nil unless block_type.is_a?(Type::Constant)
+
+          block_type.value ? :truthy : :falsey
+        end
+
+        # Filter-shaped methods collapse to either the receiver
+        # (every element kept) or the empty tuple (every element
+        # dropped). Tuple-shaped receivers widen to
+        # `Array[union of elements]` on the all-kept side because
+        # we cannot prove WHICH positional subset survives —
+        # Tuple's per-position semantics do not carry over to a
+        # filtered Array.
+        def fold_filter(receiver, method_name, truthiness)
+          return nil unless filter_receiver_known?(receiver)
+
+          keep_all = filter_keeps_all?(method_name, truthiness)
+          keep_all ? receiver_as_kept_array(receiver) : Type::Combinator.tuple_of
+        end
+
+        def filter_keeps_all?(method_name, truthiness)
+          (FILTER_KEEP_ON_TRUTHY.include?(method_name) && truthiness == :truthy) ||
+            (FILTER_KEEP_ON_FALSEY.include?(method_name) && truthiness == :falsey)
+        end
+
+        def receiver_as_kept_array(receiver)
+          case receiver
+          when Type::Tuple then tuple_to_array(receiver)
+          else receiver
+          end
+        end
+
+        def tuple_to_array(tuple)
+          return Type::Combinator.tuple_of if tuple.elements.empty?
+          return Type::Combinator.nominal_of("Array", type_args: [tuple.elements.first]) if tuple.elements.size == 1
+
+          element = Type::Combinator.union(*tuple.elements)
+          Type::Combinator.nominal_of("Array", type_args: [element])
+        end
+
+        # Predicate folds. The decision table mirrors Ruby's
+        # actual semantics on `Enumerable#all?` / `#any?` /
+        # `#none?` — see the table at the top of the module.
+        def fold_predicate(receiver, method_name, truthiness)
+          emptiness = receiver_emptiness(receiver)
+          decision = predicate_decision(method_name, truthiness, emptiness)
+          return nil if decision.nil?
+
+          case decision
+          when :always_true  then Type::Combinator.constant_of(true)
+          when :always_false then Type::Combinator.constant_of(false)
+          when :bool         then bool_union
+          end
+        end
+
+        # @return [:always_true, :always_false, :bool, nil]
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def predicate_decision(method_name, truthiness, emptiness)
+          case method_name
+          when :all?
+            return :always_true if truthiness == :truthy
+            return :always_true if emptiness == :empty
+            return :always_false if emptiness == :non_empty
+
+            :bool
+          when :any?
+            return :always_false if truthiness == :falsey
+            return :always_true if emptiness == :non_empty
+            return :always_false if emptiness == :empty
+
+            :bool
+          when :none?
+            return :always_true if truthiness == :falsey
+            return :always_false if emptiness == :non_empty
+            return :always_true if emptiness == :empty
+
+            :bool
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def bool_union
+          Type::Combinator.union(
+            Type::Combinator.constant_of(true),
+            Type::Combinator.constant_of(false)
+          )
+        end
+
+        # @return [:empty, :non_empty, :unknown]
+        def receiver_emptiness(receiver)
+          case receiver
+          when Type::Tuple
+            receiver.elements.empty? ? :empty : :non_empty
+          when Type::HashShape
+            receiver.pairs.empty? ? :empty : :non_empty
+          when Type::Constant
+            constant_emptiness(receiver.value)
+          when Type::Difference
+            difference_emptiness(receiver)
+          else
+            :unknown
+          end
+        end
+
+        def constant_emptiness(value)
+          # Only `Range` constants reach these folds: `Type::Constant`
+          # rejects Array / Hash literals (they become `Tuple` /
+          # `HashShape` carriers), and the remaining scalar
+          # constants (Integer / Float / Symbol / String / …)
+          # are not Enumerable receivers for the filter or
+          # predicate methods folded here.
+          return range_emptiness(value) if value.is_a?(Range)
+
+          :unknown
+        end
+
+        def range_emptiness(range)
+          beg = range.begin
+          en  = range.end
+          return :unknown unless beg.is_a?(Numeric) && en.is_a?(Numeric)
+
+          if range.exclude_end?
+            beg < en ? :non_empty : :empty
+          else
+            beg <= en ? :non_empty : :empty
+          end
+        end
+
+        # `non-empty-array[T]` is encoded as
+        # `Difference[Array[T], Tuple[]]` — the imported built-in
+        # carrier for non-emptiness. Recognising it here lets
+        # `arr.any? { true }` fold to `Constant[true]` for
+        # callers who threaded the non-emptiness through their
+        # type signature.
+        def difference_emptiness(diff)
+          base = diff.base
+          removed = diff.removed
+          return :unknown unless removed.is_a?(Type::Tuple) && removed.elements.empty?
+          return :non_empty if array_or_hash_nominal?(base)
+
+          :unknown
+        end
+
+        def array_or_hash_nominal?(type)
+          type.is_a?(Type::Nominal) && %w[Array Hash Set].include?(type.class_name)
+        end
+
+        # Filter folds need at least a recognised collection
+        # carrier; `Top` / `Dynamic` / arbitrary nominals decline
+        # so the RBS tier answers (its `Array#select { … } -> Array[T]`
+        # projection is correct, just less precise on the empty
+        # endpoint).
+        def filter_receiver_known?(receiver)
+          case receiver
+          when Type::Tuple, Type::HashShape, Type::Constant, Type::Difference then true
+          when Type::Nominal then %w[Array Hash Set Range].include?(receiver.class_name)
+          else false
+          end
+        end
+
+        # `find` / `detect` / `find_index` / `index` (block form)
+        # short-circuit to nil when the block is provably falsey.
+        # `index` and `find_index` also accept a non-block argument
+        # form (`arr.index(value)`); we decline whenever the call
+        # carries a positional argument so the RBS tier still
+        # answers the value-search variant correctly.
+        def fold_falsey_nil_short_circuit(_method_name, truthiness, args)
+          return nil unless args.empty?
+          return nil unless truthiness == :falsey
+
+          Type::Combinator.constant_of(nil)
+        end
+
+        # `count` with a block returns the count of elements
+        # for which the block is truthy. The non-block forms
+        # (`count` / `count(value)`) carry positional arguments
+        # and are handled by the RBS tier; this fold only fires
+        # when the block is the sole source of selection.
+        def fold_count(receiver, truthiness, args)
+          return nil unless args.empty?
+          return Type::Combinator.constant_of(0) if truthiness == :falsey
+
+          fold_count_truthy(receiver)
+        end
+
+        def fold_count_truthy(receiver)
+          size = finite_size(receiver)
+          return nil if size.nil?
+
+          Type::Combinator.constant_of(size)
+        end
+
+        # Returns the receiver's known finite element count, or
+        # nil when the carrier does not pin a size. Tuple and
+        # HashShape are pinned by construction; `Constant<…>`
+        # exposes the literal's `.size`. Other shapes (Array[T],
+        # Range[T], Nominal) decline so the RBS tier widens.
+        def finite_size(receiver)
+          case receiver
+          when Type::Tuple then receiver.elements.size
+          when Type::HashShape then receiver.pairs.size
+          when Type::Constant then constant_size(receiver.value)
+          end
+        end
+
+        def constant_size(value)
+          # Mirrors `constant_emptiness` — only `Range` produces
+          # a meaningful finite size for the methods folded here.
+          range_size(value) if value.is_a?(Range)
+        end
+
+        def range_size(range)
+          beg = range.begin
+          en  = range.end
+          return nil unless beg.is_a?(Integer) && en.is_a?(Integer)
+
+          range.exclude_end? ? [en - beg, 0].max : [en - beg + 1, 0].max
+        end
+      end
+    end
+  end
+end