rigortype 0.3.7 → 0.3.9

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

@@ -214,7 +214,6 @@ module Rigor
         # survives the call.
         CONSTANT_SELF_RETURNERS = %i[freeze itself dup clone].to_set.freeze
 
-        # @return [Rigor::Type::Constant, Rigor::Type::Union, Rigor::Type::IntegerRange, nil]
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -234,15 +233,8 @@ module Rigor
             first_arg = args.first
             return nil unless first_arg.is_a?(Type::Constant) && first_arg.value.is_a?(Symbol)
           end
-          self_return = try_fold_self_return(receiver, method_name, args)
-          return self_return if self_return
-
-          # v0.0.7 — `String#%` against a `Tuple` / `HashShape` argument runs Ruby's format-string engine
-          # when both sides are statically constant. The standard `numeric_set_of` path bails on Tuple /
-          # HashShape arguments because they are not scalar-Constant carriers, so the special-case sits
-          # ahead of the numeric path.
-          format_lift = try_fold_string_format(receiver, method_name, args)
-          return format_lift if format_lift
+          ahead = try_fold_ahead_of_numeric_path(receiver, method_name, args)
+          return ahead if ahead
 
           receiver_set = numeric_set_of(receiver)
           return nil unless receiver_set
@@ -253,6 +245,20 @@ module Rigor
           dispatch_by_arity(receiver_set, method_name, arg_sets)
         end
 
+        # The folds that must answer before `numeric_set_of` gets a say, because the receiver or an
+        # argument is a carrier it declines:
+        #
+        # - the self-returners, whose receiver may be any `Constant`;
+        # - v0.0.7's `String#%` against a `Tuple` / `HashShape` argument, neither a scalar-Constant
+        #   carrier, which runs Ruby's own format-string engine;
+        # - #861's `clamp` on a plain `Integer` / `Float` receiver, a `Nominal` that `numeric_set_of`
+        #   declines outright.
+        def try_fold_ahead_of_numeric_path(receiver, method_name, args)
+          try_fold_self_return(receiver, method_name, args) ||
+            try_fold_string_format(receiver, method_name, args) ||
+            try_fold_unbounded_clamp(receiver, method_name, args)
+        end
+
         # `freeze` / `itself` / `dup` / `clone` on a value-pinned receiver return the receiver carrier.
         #
         # This sits AHEAD of the catalogue path and deliberately bypasses its purity gate, because the gate
@@ -344,11 +350,13 @@ module Rigor
             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
+            # running fixpoint assumption `1 | Integer[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
+          # ADR-109 — a bounded Float folds through its own arms (`try_fold_unary_float_range`,
+          # `try_fold_ternary_float_range`, `try_fold_clamp_range`); every other arm declines it.
+          when Type::IntegerRange, Type::FloatRange then type
           end
         end
 
@@ -390,11 +398,15 @@ module Rigor
           case set
           when Array              then try_fold_unary_set(set, method_name)
           when Type::IntegerRange then try_fold_unary_range(set, method_name)
+          when Type::FloatRange   then try_fold_unary_float_range(set, method_name)
           end
         end
 
         def try_fold_binary(left, method_name, right)
           return try_fold_divmod(left, right) if method_name == :divmod
+          return try_fold_clamp_range(left, right) if method_name == :clamp && bounded_range?(left)
+          # ADR-109 — no Float-range arithmetic yet; a bounded Float on either side declines here.
+          return nil if left.is_a?(Type::FloatRange) || right.is_a?(Type::FloatRange)
 
           if left.is_a?(Type::IntegerRange) || right.is_a?(Type::IntegerRange)
             try_fold_binary_range(left, method_name, right)
@@ -403,6 +415,133 @@ module Rigor
           end
         end
 
+        def bounded_range?(type)
+          type.is_a?(Type::IntegerRange) || type.is_a?(Type::FloatRange)
+        end
+
+        # #834 — `clamp(range)` on a bounded receiver, the one-argument twin of `range_clamp` /
+        # `float_range_clamp`. An exclusive end raises at run time (`cannot clamp with an exclusive
+        # range`), so it declines rather than folding a call that does not return; a missing end keeps
+        # the receiver's own bound on that side. The bracket's endpoints must be literals of the
+        # receiver's class.
+        def try_fold_clamp_range(receiver, right)
+          bracket = clamp_bracket(right)
+          return nil if bracket.nil?
+
+          lower, upper = bracket
+          case receiver
+          when Type::IntegerRange
+            return nil unless clamp_endpoints_are?(Integer, lower, upper)
+
+            range_clamp(receiver, lower || receiver.lower, upper || receiver.upper)
+          when Type::FloatRange
+            return nil unless clamp_endpoints_are?(Numeric, lower, upper)
+
+            float_range_clamp(receiver, lower, upper)
+          end
+        end
+
+        # `[lower, upper]` of a single literal, closed, non-reversed `Range` argument (either side may be
+        # `nil` for an open range); `nil` for any other shape.
+        def clamp_bracket(right)
+          return nil unless right.is_a?(Array) && right.size == 1 && right.first.is_a?(Range)
+
+          bracket = right.first
+          return nil if bracket.exclude_end? && !bracket.end.nil?
+
+          lower = bracket.begin
+          upper = bracket.end
+          return nil if lower && upper && lower > upper
+
+          [lower, upper]
+        end
+
+        def clamp_endpoints_are?(klass, lower, upper)
+          (lower.nil? || lower.is_a?(klass)) && (upper.nil? || upper.is_a?(klass))
+        end
+
+        # #861 — `clamp` on a receiver that carries no bracket of its own. `Comparable#clamp` returns a
+        # value inside the bracket whatever the receiver's bounds are, so a plain `Integer` / `Float`
+        # receiver takes the bracket entire: `i.clamp(1..9)` and `i.clamp(1, 9)` are `Integer[1..9]`
+        # where the RBS tier's `self | A` could only say `Integer` (resp. `1 | 9 | Integer`).
+        #
+        # Endpoints must be literals of the receiver's own class. A mixed bracket is `Comparable`'s
+        # business rather than the fold's: `1.clamp(0.5, 2.5)` returns the receiver OR a bound, so the
+        # run-time class is a union across `Integer` and `Float`, and it declines here.
+        #
+        # `Float` covers `NaN` while a `FloatRange` never does — sound in this direction, because
+        # `clamp` on a NaN receiver raises (`comparison of Float with Float failed`) and the call that
+        # returns is always inside the bracket.
+        #
+        # The two run-time raisers `clamp_bracket` already declines — an exclusive end (`cannot clamp
+        # with an exclusive range`) and a reversed bracket — keep declining here.
+        def try_fold_unbounded_clamp(receiver, method_name, args)
+          return nil unless method_name == :clamp
+
+          klass = unbounded_clamp_receiver_class(receiver)
+          return nil unless klass
+
+          case args.size
+          when 1 then fold_unbounded_clamp_range(klass, args.first)
+          when 2 then fold_unbounded_clamp_pair(klass, args)
+          end
+        end
+
+        # `Integer` / `Float` for a bare nominal receiver of that class; `nil` for everything else,
+        # the bounded carriers included — those keep their own intersecting folds.
+        def unbounded_clamp_receiver_class(receiver)
+          return nil unless receiver.is_a?(Type::Nominal) && receiver.type_args.empty?
+
+          case receiver.class_name
+          when "Integer" then Integer
+          when "Float" then Float
+          end
+        end
+
+        def fold_unbounded_clamp_range(klass, arg)
+          bracket = clamp_bracket(numeric_set_of(arg))
+          return nil if bracket.nil?
+
+          lower, upper = bracket
+          return nil unless clamp_endpoints_are?(klass, lower, upper)
+          return nil if clamp_bound_nan?(lower) || clamp_bound_nan?(upper)
+
+          unbounded_clamp_result(klass, lower, upper)
+        end
+
+        def fold_unbounded_clamp_pair(klass, args)
+          values = args.map { |arg| single_clamp_bound(klass, numeric_set_of(arg)) }
+          lower, upper = values
+          return nil if lower.nil? || upper.nil?
+          return nil if lower > upper
+
+          unbounded_clamp_result(klass, lower, upper)
+        end
+
+        # The two-argument form takes no `nil` bound: `clamp(nil, 9)` is `Comparable`'s own
+        # one-sided form, which the catalogue does not route here.
+        def single_clamp_bound(klass, values)
+          return nil unless values.is_a?(Array) && values.size == 1
+
+          value = values.first
+          return nil unless value.is_a?(klass)
+
+          clamp_bound_nan?(value) ? nil : value
+        end
+
+        # A NaN bound orders against nothing, so `clamp` raises for it — no bracket to fold to.
+        def clamp_bound_nan?(bound)
+          bound.is_a?(Float) && bound.nan?
+        end
+
+        def unbounded_clamp_result(klass, lower, upper)
+          if klass == Integer
+            build_integer_range(lower || -Float::INFINITY, upper || Float::INFINITY)
+          else
+            Type::Combinator.float_range(lower || -Float::INFINITY, upper || Float::INFINITY)
+          end
+        end
+
         # `Integer#divmod` and `Float#divmod` return a 2-element array `[quotient, remainder]`. We project
         # that into `Tuple[Constant[q], Constant[r]]` so downstream rules see the precise element types.
         # Union/range receivers are widened per-position: each tuple slot carries the union of quotients
@@ -870,16 +1009,70 @@ module Rigor
         # could not reach.
         #
         # v0.0.6 — IntegerRange-shaped receivers participate in `Comparable#between?` and
-        # `Comparable#clamp` folds. `int<a,b>.between?(min, max)` decides three-valued via the receiver's
-        # bounds against scalar args; `int<a,b>.clamp` narrows the receiver's bounds against the bracket.
+        # `Comparable#clamp` folds. `Integer[a..b].between?(min, max)` decides three-valued via the receiver's
+        # bounds against scalar args; `Integer[a..b].clamp` narrows the receiver's bounds against the bracket.
         # Other ternary methods over IntegerRange operands still decline.
         def try_fold_ternary(receiver_set, method_name, arg_sets)
           return try_fold_ternary_range(receiver_set, method_name, arg_sets) if receiver_set.is_a?(Type::IntegerRange)
-          return nil if arg_sets.any?(Type::IntegerRange)
+          if receiver_set.is_a?(Type::FloatRange)
+            return try_fold_ternary_float_range(receiver_set, method_name, arg_sets)
+          end
+          return nil if arg_sets.any? { |s| bounded_range?(s) }
 
           try_fold_ternary_set(receiver_set, method_name, arg_sets)
         end
 
+        # ADR-109 — receiver `FloatRange` + two scalar numeric args: `between?` decides three-valued
+        # over the bracket, `clamp` narrows to the bracket (NaN never inhabits the receiver, so the
+        # comparison that would raise on NaN cannot).
+        def try_fold_ternary_float_range(range, method_name, arg_sets)
+          return nil unless arg_sets.all?(Array)
+
+          min_arg = single_real_arg(arg_sets[0])
+          max_arg = single_real_arg(arg_sets[1])
+          return nil if min_arg.nil? || max_arg.nil?
+          return nil if min_arg > max_arg
+
+          case method_name
+          when :between? then float_range_between(range, min_arg, max_arg)
+          when :clamp then float_range_clamp(range, min_arg, max_arg)
+          end
+        end
+
+        def single_real_arg(values)
+          return nil unless values.is_a?(Array) && values.size == 1
+
+          v = values.first
+          return nil unless v.is_a?(Integer) || (v.is_a?(Float) && !v.nan?)
+
+          v
+        end
+
+        def float_range_between(range, min_arg, max_arg)
+          return Type::Combinator.constant_of(false) if range.canonical_max < min_arg || range.min > max_arg
+          return Type::Combinator.constant_of(true) if range.min >= min_arg && range.canonical_max <= max_arg
+
+          bool_union
+        end
+
+        # `Float[a..b].clamp(lo, hi)` (either bound may be `nil` for the one-argument `clamp(lo..)` /
+        # `clamp(..hi)` forms). Keeps the receiver's own end, exclusivity included, where it is the
+        # tighter one. When the bracket lies wholly outside the receiver every value snaps to one bound
+        # and the result is a point Rigor would have to invent, so it declines like the Integer twin.
+        def float_range_clamp(range, min_arg, max_arg)
+          new_min = min_arg.nil? ? range.min : [range.min, min_arg.to_f].max
+          if max_arg.nil? || max_arg.to_f >= range.canonical_max
+            new_max = range.max
+            exclusive = range.exclude_end?
+          else
+            new_max = max_arg.to_f
+            exclusive = false
+          end
+          return nil if new_min > (exclusive ? new_max.prev_float : new_max)
+
+          Type::Combinator.float_range(new_min, new_max, exclude_end: exclusive)
+        end
+
         # Receiver IntegerRange + two scalar `Constant<Integer>` args — the only IntegerRange-aware ternary
         # fold today. `between?` returns Trinary truthiness over the bracket; `clamp` returns the
         # intersected IntegerRange (or a collapsed Constant if the result pins a single point).
@@ -904,7 +1097,7 @@ module Rigor
           v.is_a?(Integer) ? v : nil
         end
 
-        # `int<a,b>.between?(min, max)`:
+        # `Integer[a..b].between?(min, max)`:
         # - Constant[true] when [a,b] ⊆ [min,max] (and finite).
         # - Constant[false] when [a,b] ∩ [min,max] is empty.
         # - bool union otherwise.
@@ -916,7 +1109,7 @@ module Rigor
           bool_union
         end
 
-        # `int<a,b>.clamp(min, max)`:
+        # `Integer[a..b].clamp(min, max)`:
         # - new_lower = max(a, min), new_upper = min(b, max).
         # - When new_lower > new_upper the bracket excluded the range entirely; the call still returns one
         #   of the bracket bounds at runtime, but Rigor is strictly less precise here than Ruby — decline
@@ -1112,8 +1305,8 @@ module Rigor
         end
 
         # Range % Range. Only the `(any range) % (positive constant n)` and `(any range) % (negative
-        # constant n)` cases are folded precisely — the former narrows to `int<0, n-1>`, the latter to
-        # `int<n+1, 0>`. Other shapes fall back to nil.
+        # constant n)` cases are folded precisely — the former narrows to `Integer[0..n-1]`, the latter to
+        # `Integer[n+1..0]`. Other shapes fall back to nil.
         def range_modulo(_left, right)
           return nil unless right.finite? && right.min == right.max
 
@@ -1220,6 +1413,99 @@ module Rigor
         }.freeze
         private_constant :UNARY_RANGE_DIRECT
 
+        # ADR-109 — unary folds over a bounded Float. No bounded range contains NaN, so the predicates
+        # that exist to detect it are decided outright, and the monotone conversions map the two bounds.
+        # An exclusive end is dropped where negation would turn it into an exclusive begin, a shape
+        # Ruby's literal cannot spell: the result is the closed envelope, a superset.
+        FLOAT_RANGE_UNARY = {
+          abs: :float_range_abs,
+          magnitude: :float_range_abs,
+          "-@": :float_range_negate,
+          "+@": :float_range_identity,
+          to_f: :float_range_identity,
+          nan?: :float_range_never_nan,
+          finite?: :float_range_finite,
+          zero?: :float_range_zero,
+          positive?: :float_range_positive,
+          negative?: :float_range_negative,
+          floor: :float_range_to_integer,
+          ceil: :float_range_to_integer,
+          round: :float_range_to_integer,
+          truncate: :float_range_to_integer,
+          to_i: :float_range_to_integer
+        }.freeze
+        private_constant :FLOAT_RANGE_UNARY
+
+        def try_fold_unary_float_range(range, method_name)
+          handler = FLOAT_RANGE_UNARY[method_name]
+          return nil if handler.nil?
+
+          send(handler, range, method_name)
+        end
+
+        def float_range_abs(range, _method_name)
+          lower = range.min
+          upper = range.canonical_max
+          return range if lower >= 0.0
+          return Type::Combinator.float_range(-upper, -lower) if upper <= 0.0
+
+          Type::Combinator.float_range(0.0, [-lower, upper].max)
+        end
+
+        def float_range_negate(range, _method_name)
+          Type::Combinator.float_range(-range.canonical_max, -range.min)
+        end
+
+        def float_range_identity(range, _method_name)
+          range
+        end
+
+        def float_range_never_nan(_range, _method_name)
+          Type::Combinator.constant_of(false)
+        end
+
+        def float_range_finite(range, _method_name)
+          lower = range.min
+          upper = range.canonical_max
+          return Type::Combinator.constant_of(true) if lower.finite? && upper.finite?
+          return Type::Combinator.constant_of(false) if lower == upper
+
+          bool_union
+        end
+
+        def float_range_zero(range, _method_name)
+          return Type::Combinator.constant_of(false) unless range.covers?(0.0)
+          return Type::Combinator.constant_of(true) if range.min.zero? && range.canonical_max.zero?
+
+          bool_union
+        end
+
+        # `Float#positive?` is `self > 0`, `negative?` is `self < 0`.
+        def float_range_positive(range, _method_name)
+          return Type::Combinator.constant_of(true) if range.min > 0.0
+          return Type::Combinator.constant_of(false) if range.canonical_max <= 0.0
+
+          bool_union
+        end
+
+        def float_range_negative(range, _method_name)
+          return Type::Combinator.constant_of(true) if range.canonical_max < 0.0
+          return Type::Combinator.constant_of(false) if range.min >= 0.0
+
+          bool_union
+        end
+
+        # `floor` / `ceil` / `round` / `truncate` / `to_i` are monotone, so the image of the range is the
+        # integer range between the images of its bounds. An infinite bound raises `FloatDomainError` at
+        # run time for the value that reaches it, so the fold declines and the RBS `Integer` stands.
+        def float_range_to_integer(range, method_name)
+          lower = range.min
+          upper = range.canonical_max
+          return nil if lower.infinite? || upper.infinite?
+
+          build_integer_range(lower.public_send(method_name), upper.public_send(method_name))
+        end
+
         def try_fold_unary_range(range, method_name)
           return range_unary_predicate(range, method_name) if RANGE_UNARY_PREDICATES.include?(method_name)
           return range_unary_shift(range, method_name) if RANGE_UNARY_SHIFTS.include?(method_name)

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

@@ -31,7 +31,7 @@ module Rigor
         # and the reader-redefinition guard are shared with {StructFolding}.
         extend MemberShapeProjection
 
-        # @return [Rigor::Type, nil] the folded result, or nil to defer.
+        # @return the folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
 

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

@@ -73,7 +73,7 @@ module Rigor
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer
+        # @return folded result, or nil to defer
         #   to the next dispatcher tier.
         def try_dispatch(context)
           receiver = context.receiver

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

@@ -16,7 +16,7 @@ module Rigor
       # Each rule mirrors Ruby's actual iteration semantics:
       #
       # - `n.times { |i| … }` yields `i ∈ [0, n-1]` when `n > 0`, nothing otherwise. The block-param type is
-      #   therefore `int<0, n-1>` for a `Constant<Integer>` receiver, `int<0, upper-1>` for a finite
+      #   therefore `Integer[0..n-1]` for a `Constant<Integer>` receiver, `Integer[0..upper-1]` for a finite
       #   `IntegerRange`, and `non_negative_int` for any unbounded-above shape.
       # - `a.upto(b) { |i| … }` yields `i ∈ [a, b]` when `a <= b`. Lower bound from the receiver, upper
       #   bound from the argument.
@@ -25,7 +25,7 @@ module Rigor
       module IteratorDispatch
         module_function
 
-        # @return [Array<Rigor::Type>, nil] block-param types, or
+        # @return block-param types, or
         #   nil to fall through to the next tier.
         def block_param_types(context)
           receiver = context.receiver

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

@@ -41,7 +41,7 @@ module Rigor
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        # @return folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name

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

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "constant_folding"
+require_relative "random_folding"
 
 module Rigor
   module Inference
@@ -43,7 +44,7 @@ module Rigor
         # every entry is spelling-parity checked. Public (not private_constant) and Ractor-shareable
         # because the gate and the spec both read it.
         INTRINSIC_NAMES = Ractor.make_shareable(
-          Set[:Array, :Integer, :Float, :Rational, :Complex, :p, :pp, :String, :Hash, :format, :sprintf]
+          Set[:Array, :Integer, :Float, :Rational, :Complex, :p, :pp, :String, :Hash, :format, :sprintf, :rand]
         )
 
         # `Kernel#Rational` / `Kernel#Complex` constructor folds. When every argument is a `Type::Constant`
@@ -101,6 +102,11 @@ module Rigor
           return try_string(context) if method_name == :String
           return try_hash(context) if method_name == :Hash
           return try_format(context) if FORMAT_METHODS.include?(method_name)
+          # ADR-109 / #833 — `Kernel#rand(a..b)` lands in the literal range, a bounded carrier of the
+          # range's own class (never a constant: the generator advances). The other argument shapes
+          # stay unfolded on purpose; {RandomFolding} owns the `Random.rand` spelling and the reading.
+          # A splat still declines: the reading needs exactly one literal-Range argument.
+          return RandomFolding.interval_for_args(args) if method_name == :rand
 
           nil
         end

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

@@ -44,11 +44,23 @@ module Rigor
         MATH_BINARY = Set[:atan2, :hypot, :ldexp].freeze
         MATH_TUPLE_UNARY = Set[:frexp, :lgamma].freeze
 
-        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY
+        # ADR-109 — the monotone non-decreasing functions, each with the inclusive lower edge of its
+        # domain (`nil` for every real). Over a bounded argument the image is the closed range between the
+        # images of the bounds: `Math.sqrt(Integer[0..])` is `Float[0.0..]`, `Math.exp(Float[..0.0])` is
+        # `Float[0.0..1.0]`. A bound below the domain edge raises at run time for the value that reaches
+        # it, so the fold declines. Not listed: the non-monotone functions (`sin`, `cos`, `tan`, `gamma`,
+        # `erfc` decreases, `acos` decreases) and the ones whose image needs a sign split.
+        MATH_MONOTONE_DOMAIN = {
+          sqrt: 0.0, cbrt: nil, exp: nil, expm1: nil,
+          log: 0.0, log2: 0.0, log10: 0.0, log1p: -1.0,
+          atan: nil, sinh: nil, tanh: nil, asinh: nil, erf: nil
+        }.freeze
+
+        private_constant :MATH_UNARY, :MATH_BINARY, :MATH_TUPLE_UNARY, :MATH_MONOTONE_DOMAIN
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        # @return folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -77,13 +89,38 @@ module Rigor
           return nil unless args.size == 1
 
           x = numeric_constant(args.first)
-          return nil if x.nil?
+          return fold_monotone_range(method_name, args.first) if x.nil?
 
           fold_float_result(Math.public_send(method_name, x))
         rescue Math::DomainError, RangeError
           nil
         end
 
+        # The bounded-argument arm of {fold_unary} / {fold_log}: an `IntegerRange` or `FloatRange`
+        # argument to a monotone function folds to the range between the images of its bounds.
+        def fold_monotone_range(method_name, arg)
+          return nil unless MATH_MONOTONE_DOMAIN.key?(method_name)
+
+          lower, upper = range_bounds(arg)
+          return nil if lower.nil?
+
+          edge = MATH_MONOTONE_DOMAIN[method_name]
+          return nil if edge && lower < edge
+
+          Type::Combinator.float_range(Math.public_send(method_name, lower), Math.public_send(method_name, upper))
+        rescue Math::DomainError, RangeError, ArgumentError
+          nil
+        end
+
+        # `[lower, upper]` as doubles for a bounded numeric carrier, `nil` for anything else. An
+        # exclusive Float end reads as its canonical closed bound, one double below.
+        def range_bounds(arg)
+          case arg
+          when Type::FloatRange then [arg.min, arg.canonical_max]
+          when Type::IntegerRange then [arg.lower.to_f, arg.upper.to_f]
+          end
+        end
+
         def fold_binary(method_name, args)
           return nil unless args.size == 2
 
@@ -101,6 +138,7 @@ module Rigor
           return nil unless [1, 2].include?(args.size)
 
           values = args.map { |a| numeric_constant(a) }
+          return fold_monotone_range(:log, args.first) if args.size == 1 && values.first.nil?
           return nil if values.any?(&:nil?)
 
           fold_float_result(Math.log(*values))

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

@@ -29,11 +29,8 @@ module Rigor
         # `.method("name")` with a precisely-known Symbol / String argument. Declines on every other shape
         # so the RBS tier still answers `Method` for non-folding cases.
         #
-        # @param receiver [Rigor::Type] caller's receiver
-        # @param method_name [Symbol] the method being dispatched on `receiver` — only `:method` triggers
-        #   the fold.
-        # @param args [Array<Rigor::Type>] caller's argument types in order. Only the single-argument case
-        #   matches; other arities decline.
+        # Reads `context.receiver`, `context.method_name` (only `:method` triggers the fold) and `context.args`
+        # (only the single-argument case matches; other arities decline).
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name