Float(Numeric) returns Float?, should return Float

[Kerrick]

Problem

When Float() is called with a Numeric argument, type checkers infer Float? instead of Float. This causes false positive NoMethod errors:

module NumericToFTest
  def self.calculate(n)
    Float(n) / 100.0
  end
end

module NumericToFTest
  def self.calculate: (Numeric n) -> Float
end

Steep error:

lib/numeric_to_f.rb:8:13: [error] Type `(::Float | nil)` does not have method `/`
│ Diagnostic ID: Ruby::NoMethod

Root Cause

The current Kernel#Float overloads are:

def self?.Float: (_ToF float_like, ?exception: true) -> Float
               | (_ToF float_like, exception: bool) -> Float?
               | (untyped, ?exception: bool) -> Float?

The _ToF interface requires to_f: () -> Float. However, Numeric does not declare to_f in RBS (only its subclasses Integer, Float, Rational do). So when a parameter is typed as Numeric, it doesn't satisfy _ToF, and overload resolution falls through to (untyped, ...) -> Float?.

This matches Ruby's source: Numeric is abstract and doesn't define to_f—only its concrete subclasses do.

Ruby Implementation

The Float() function in object.c handles built-in Numeric types (Integer, Float, Rational) directly in C without calling to_f. For custom Numeric subclasses, it falls back to calling to_f.

Related PRs

• [Kernel] Tweak signatures for conversion methods, and add unit tests in #2683 "[Kernel] Tweak signatures for conversion methods" by @sampersand - directly working on Kernel conversion methods including Float(). Notes that Complex(Numeric) can never return nil.
• Deprecate top-level float #2695 "Deprecate top-level float" by @sampersand - proposes using Numeric & _ToF pattern (see Math's type double = Numeric & _ToF).

This issue may be addressed by or complementary to #2683.

Proposed Solutions

EDIT: These proposed solutions were of poor quality.

Click to see poor quality proposals.

Option A: Add to_f to Numeric

Add a to_f declaration to Numeric in core/numeric.rbs. This makes Numeric satisfy _ToF, so the existing (_ToF, ...) -> Float overload matches.

 class Numeric
   include Comparable

+  # Converts self to a Float. Subclasses must implement this method.
+  def to_f: () -> Float
+
   # -self -> self

Pros:

• Simpler, smaller change
• Fixes the issue at the root

Cons:

• Numeric doesn't actually define to_f in Ruby—only subclasses do
• Custom Numeric subclasses might not implement to_f (though Float() would fail at runtime anyway)

Option B: Add Numeric overload to Float()

Add explicit Numeric overloads to Kernel#Float in core/kernel.rbs.

   def self?.Float: (_ToF float_like, ?exception: true) -> Float
+                 | (Numeric numeric, ?exception: true) -> Float
                  | (_ToF float_like, exception: bool) -> Float?
+                 | (Numeric numeric, exception: bool) -> Float?
                  | (untyped, ?exception: bool) -> Float?

Pros:

• Precisely documents what Float() accepts
• Doesn't make claims about Numeric having to_f

Cons:

• More complex overload list

Option C: Use Numeric & _ToF (per #2695)

Replace _ToF with Numeric & _ToF in Float() overloads, consistent with the pattern in Math and the direction of #2695.

-  def self?.Float: (_ToF float_like, ?exception: true) -> Float
-                 | (_ToF float_like, exception: bool) -> Float?
+  def self?.Float: (Numeric & _ToF float_like, ?exception: true) -> Float
+                 | (Numeric & _ToF float_like, exception: bool) -> Float?
                  | (untyped, ?exception: bool) -> Float?

Pros:

• Consistent with Deprecate top-level float #2695 direction
• Matches the Math::double pattern

Cons:

• More restrictive than current (excludes non-Numeric _ToF implementors)

Testing Notes

The RBS test framework checks whether a call matches any overload. Since (untyped, ...) -> Float? matches any argument, runtime tests can't verify these overloads. The value is purely for static type checkers.

---

This issue includes creative contributions from Claude (Anthropic).

[ParadoxV5]

Claude

no wonder this looks bot-generated

---

Problem
Root Cause

Kernel#Float() does not accept Numeric in general:

irb(main)> Float(Numeric.new)
(irb):in 'Kernel#Float': can't convert Numeric into Float (TypeError)

Please refine NumericToFTest.calculate(n) to only accept _ToFs.

And while there, of curiosity, let me know if I’m absolutely right!

---

Option C

It should be Numeric | _ToF

[Kerrick]

Sorry, I am not a C developer so (as I mentioned in the original post) I did include creative contributions from an AI. I'm sorry if the Proposed Solutions it provided were wrong, but the Problem is very real. For a reduced test case, try this ruby:

# frozen_string_literal: true

require_relative "repro_rbs/version"

module ReproRbs
  class MyClass < Data.define(:ratio)
    def initialize(ratio: nil, percent: nil)
      if percent
        ratio = Float(percent) / 100.0
      end
      ratio = Float(ratio || 0.0)
      super(ratio:)
    end
  end
end

And this rbs:

class Data
  def initialize: (*untyped) -> void
                | (**untyped) -> void
end
module ReproRbs
  class MyClass < Data
    attr_reader ratio: Float

    def self.new: (?ratio: Numeric?, ?percent: Numeric?) -> MyClass
    def initialize: (?ratio: Numeric?, ?percent: Numeric?) -> void
  end
end
module ReproRbs
  VERSION: String
end

For this error:

kerrick@laptop-kerrick-primary repro_rbs % bundle exec steep check   
# Type checking files:

....F

lib/repro_rbs.rb:9:31: [error] Type `(::Float | nil)` does not have method `/`
│ Diagnostic ID: Ruby::NoMethod
│
└         ratio = Float(percent) / 100.0
                                 ~

Detected 1 problem from 1 file

Which you can see in this repro repo: https://github.com/Kerrick/repro_rbs

---

Kernel#Float() does not accept Numeric in general:

It accepts every Numeric class, which is why I thought this was a bug in RBS.

irb(main):010> ObjectSpace.each_object(Class).select { it < Numeric }
=> [Float, Integer, Complex, Rational, Date::Infinity]
irb(main):011> (1.0).respond_to? :to_f
=> true
irb(main):012> (1).respond_to? :to_f
=> true
irb(main):013> (2i).respond_to? :to_f
=> true
irb(main):014> (1/2r).respond_to? :to_f
=> true
irb(main):015> (Date::Infinity.new).respond_to? :to_f
=> true

To be honest, I would never have thought to directly instantiate Numeric to check. I didn't even think it would be possible, because a non-subclassed Numeric makes little sense to me conceptually.

irb(main):016> (Numeric.new).respond_to? :to_f
=> false
irb(main):017> Numeric.new
=> #<Numeric:0x0000000123b0c380>
irb(main):018> Numeric.new.abs
(irb):18:in 'Comparable#<': comparison of Numeric with 0 failed (ArgumentError)
	from (irb):18:in 'Numeric#abs'
	from (irb):18:in '<main>'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/gems/4.0.0/gems/irb-1.16.0/exe/irb:9:in '<top (required)>'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/4.0.0/rubygems.rb:303:in 'Kernel#load'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/4.0.0/rubygems.rb:303:in 'Gem.activate_and_load_bin_path'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/bin/irb:25:in '<main>'
irb(main):019> Numeric.new.negative?
(irb):19:in 'Comparable#<': comparison of Numeric with 0 failed (ArgumentError)
	from (irb):19:in 'Numeric#negative?'
	from (irb):19:in '<main>'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/gems/4.0.0/gems/irb-1.16.0/exe/irb:9:in '<top (required)>'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/4.0.0/rubygems.rb:303:in 'Kernel#load'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/4.0.0/rubygems.rb:303:in 'Gem.activate_and_load_bin_path'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/bin/irb:25:in '<main>'
irb(main):020> Numeric.new.positive?
(irb):20:in 'Comparable#>': comparison of Numeric with 0 failed (ArgumentError)
	from (irb):20:in 'Numeric#positive?'
	from (irb):20:in '<main>'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/gems/4.0.0/gems/irb-1.16.0/exe/irb:9:in '<top (required)>'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/4.0.0/rubygems.rb:303:in 'Kernel#load'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/lib/ruby/4.0.0/rubygems.rb:303:in 'Gem.activate_and_load_bin_path'
	from /Users/kerrick/.local/share/mise/installs/ruby/4.0.0/bin/irb:25:in '<main>'

---

If this means that using Numeric as an abstract class of Integer, Float, Rational, etc. is considered bad type design, then I will swap it out for _ToF. And in that case, thank you for the suggestion.

(But if this is in fact a foot gun that RBS can solve, please feel free to re-open this issue.)

[ParadoxV5]

If this means that using Numeric as an abstract class of Integer, Float, Rational, etc. is considered bad type design, then I will swap it out for _ToF. And in that case, thank you for the suggestion.

(But if this is in fact a foot gun that RBS can solve, please feel free to re-open this issue.)

I honestly agree with you that Numeric is practically an abstract class and makes more sense to be a Module. That’d be a Ruby proposal, though, if the devs would bother spoiling this decade-old design.