From e7efeb459289262a2864548029905b489326f246 Mon Sep 17 00:00:00 2001
From: SamW <mail@sampersand.me>
Date: Thu, 8 Feb 2024 16:09:12 -0800
Subject: [PATCH] Update Rational

---
 core/numeric.rbs             |  65 +++++++
 core/rational.rbs            | 238 +++++++++++++----------
 test/stdlib/Rational_test.rb | 354 ++++++++++++++++++++++-------------
 test/stdlib/test_helper.rb   |  16 ++
 4 files changed, 442 insertions(+), 231 deletions(-)

diff --git a/core/numeric.rbs b/core/numeric.rbs
index 613144948..a40f4d7ab 100644
--- a/core/numeric.rbs
+++ b/core/numeric.rbs
@@ -160,6 +160,71 @@
 # *   #step: Invokes the given block with the sequence of specified numbers.
 #
 class Numeric
+ interface _Coerce[Other, EquivOther, EquivSelf]
+    def coerce: (Other rhs) -> [EquivOther, EquivSelf]
+  end
+
+  interface _Add[Other, Return]
+    def +: (Other other) -> Return
+  end
+
+  interface _Subtract[Other, Return]
+    def -: (Other other) -> Return
+  end
+
+  interface _Multiply[Other, Return]
+    def *: (Other other) -> Return
+  end
+
+  interface _Divide[Other, Return]
+    def /: (Other other) -> Return
+  end
+
+  interface _Modulo[Other, Return]
+    def %: (Other other) -> Return
+  end
+
+  interface _Power[Other, Return]
+    def **: (Other other) -> Return
+  end
+
+  interface _Divmod[Other, Whole, Part]
+    def divmod: (Other other) -> [Whole, Part]
+  end
+
+  interface _Compare[Other]
+    def <=>: (Other other) -> (-1 | 0 | 1)
+           | (untyped other) -> (-1 | 0 | 1)?
+  end
+
+  interface _GreaterThan[Other, Return]
+    def >: (Other other) -> Return
+  end
+
+  interface _GreaterOrEqualTo[Other, Return]
+    def >=: (Other other) -> Return
+  end
+
+  interface _LessThan[Other, Return]
+    def <: (Other other) -> Return
+  end
+
+  interface _LessOrEqualTo[Other, Return]
+    def <=: (Other other) -> Return
+  end
+
+  type round_direction = :up | :down | :even | 'up' | 'down' | 'even' | string | nil
+
+  # The interface for the sole optional argument to subclasses of `Numeric`'s `rationalize` function.
+  interface _Eps
+    # Get the absolute value of this variable.
+    #
+    # Technically, the return value needs to be usable within `<subclass>#-` and `<subclass>#+`, but
+    # it's a bit specific; if you have a usecase for this please create a PR 
+    def abs: () -> Numeric
+  end
+
+  public
   include Comparable
 
   public
diff --git a/core/rational.rbs b/core/rational.rbs
index 1652dec67..28704bde4 100644
--- a/core/rational.rbs
+++ b/core/rational.rbs
@@ -48,13 +48,6 @@
 #                        #=> (1.0000000000000002+1.7320508075688772i)
 #
 class Rational < Numeric
-  public
-
-  def %: (Integer) -> Rational
-       | (Float) -> Float
-       | (Rational) -> Rational
-       | (Numeric) -> Numeric
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat * numeric  ->  numeric
@@ -67,9 +60,9 @@ class Rational < Numeric
   #     Rational(9, 8)  * 4                #=> (9/2)
   #     Rational(20, 9) * 9.8              #=> 21.77777777777778
   #
-  def *: (Integer) -> Rational
-       | (Rational) -> Rational
-       | [T < Numeric](T) -> T
+  def *: (Integer | Rational other) -> instance
+       | (Float other) -> Float
+       | [O < Numeric::_Multiply[S, R], S, R] (Numeric::_Coerce[self, O, S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -84,8 +77,10 @@ class Rational < Numeric
   #     Rational(1, 2) ** 0               #=> (1/1)
   #     Rational(1, 2) ** 0.0             #=> 1.0
   #
-  def **: (Complex) -> Complex
-        | (Numeric) -> Numeric
+  def **: (Integer other) -> instance
+        | (Rational other) -> (instance | Float | Complex)
+        | (Float other) -> (Float | Complex)
+        | [O < Numeric::_Power[S, R], S, R] (Numeric::_Coerce[self, O, S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -99,11 +94,9 @@ class Rational < Numeric
   #     Rational(9, 8)  + 4                #=> (41/8)
   #     Rational(20, 9) + 9.8              #=> 12.022222222222222
   #
-  def +: (Float) -> Float
-       | (Complex) -> Complex
-       | (Numeric) -> Rational
-
-  def +@: () -> Rational
+  def +: (Integer | Rational other) -> instance
+       | (Float other) -> Float
+       | [O < Numeric::_Add[S, R], S, R] (Numeric::_Coerce[self, O, S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -117,9 +110,9 @@ class Rational < Numeric
   #     Rational(9, 8)  - 4                #=> (-23/8)
   #     Rational(20, 9) - 9.8              #=> -7.577777777777778
   #
-  def -: (Float) -> Float
-       | (Complex) -> Complex
-       | (Numeric) -> Rational
+  def -: (Integer | Rational other) -> instance
+       | (Float other) -> Float
+       | [O < Numeric::_Subtract[S, R], S, R] (Numeric::_Coerce[self, O, S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -127,7 +120,7 @@ class Rational < Numeric
   # -->
   # Negates `rat`.
   #
-  def -@: () -> Rational
+  def -@: () -> instance # => Obtainable via `-Class.instance_metod(:new).bind_call(Class.new(Rational))`
 
   # <!--
   #   rdoc-file=rational.c
@@ -142,9 +135,9 @@ class Rational < Numeric
   #     Rational(9, 8)  / 4                #=> (9/32)
   #     Rational(20, 9) / 9.8              #=> 0.22675736961451246
   #
-  def /: (Float) -> Float
-       | (Complex) -> Complex
-       | (Numeric) -> Rational
+  def /: (Integer | Rational other) -> instance
+       | (Float other) -> Float
+       | [O < Numeric::_Divide[S, R], S, R] (Numeric::_Coerce[self, O, S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -163,8 +156,8 @@ class Rational < Numeric
   #
   #     Rational(1, 3) <=> "0.3"           #=> nil
   #
-  def <=>: (Integer | Rational) -> Integer
-         | (untyped) -> Integer?
+  def <=>: (Integer | Rational other) -> (-1 | 0 | 1)
+         | (untyped other) -> (-1 | 0 | 1)?
 
   # <!--
   #   rdoc-file=rational.c
@@ -178,7 +171,7 @@ class Rational < Numeric
   #     Rational('1/3') == 0.33             #=> false
   #     Rational('1/2') == '1/2'            #=> false
   #
-  def ==: (untyped) -> bool
+  def ==: (untyped object) -> bool
 
   # <!--
   #   rdoc-file=rational.c
@@ -190,13 +183,7 @@ class Rational < Numeric
   #     (1/2r).abs    #=> (1/2)
   #     (-1/2r).abs   #=> (1/2)
   #
-  def abs: () -> Rational
-
-  def abs2: () -> Rational
-
-  def angle: () -> (Integer | Float)
-
-  alias arg angle
+  def abs: () -> (instance | self)
 
   # <!--
   #   rdoc-file=rational.c
@@ -222,13 +209,12 @@ class Rational < Numeric
   #     Rational('-123.456').ceil(-1)       #=> -120
   #
   def ceil: () -> Integer
-          | (Integer digits) -> (Integer | Rational)
+          | (Integer digits) -> (Integer | instance)
 
-  def coerce: (Numeric) -> [ Numeric, Numeric ]
-
-  def conj: () -> Rational
-
-  def conjugate: () -> Rational
+  def coerce: (Integer other) -> [instance, instance]
+            | (Float other) -> [Float, Float]
+            | [R < Rational] (R other) -> [R, self]
+            | (Complex other) -> ([Complex, Complex] | [instance, instance])
 
   # <!--
   #   rdoc-file=rational.c
@@ -243,14 +229,6 @@ class Rational < Numeric
   #
   def denominator: () -> Integer
 
-  def div: (Numeric) -> Integer
-
-  def divmod: (Numeric) -> [ Numeric, Numeric ]
-
-  def dup: () -> self
-
-  def eql?: (untyped) -> bool
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.fdiv(numeric)  ->  float
@@ -261,9 +239,8 @@ class Rational < Numeric
   #     Rational(2, 3).fdiv(0.5)     #=> 1.3333333333333333
   #     Rational(2).fdiv(3)          #=> 0.6666666666666666
   #
-  def fdiv: (Numeric) -> Float
-
-  def finite?: () -> bool
+  def fdiv: (Integer | Rational | Float other) -> Float
+          | [O < Numeric::_Divide[S, R], S, R < _ToF] (Numeric::_Coerce[self, O, S] other) -> Float
 
   # <!--
   #   rdoc-file=rational.c
@@ -289,7 +266,7 @@ class Rational < Numeric
   #     Rational('-123.456').floor(-1)       #=> -130
   #
   def floor: () -> Integer
-           | (Integer digits) -> (Integer | Rational)
+           | (Integer digits) -> (Integer | instance)
 
   # <!--
   #   rdoc-file=rational.c
@@ -298,14 +275,6 @@ class Rational < Numeric
   #
   def hash: () -> Integer
 
-  def i: () -> Complex
-
-  def imag: () -> Integer
-
-  def imaginary: () -> Integer
-
-  def infinite?: () -> Integer?
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.inspect  ->  string
@@ -318,8 +287,6 @@ class Rational < Numeric
   #
   def inspect: () -> String
 
-  def integer?: () -> bool
-
   # <!-- rdoc-file=rational.c -->
   # Returns the absolute value of `rat`.
   #
@@ -328,9 +295,6 @@ class Rational < Numeric
   #
   alias magnitude abs
 
-  def modulo: (Float) -> Float
-            | (Numeric) -> Rational
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.negative?  ->  true or false
@@ -339,8 +303,6 @@ class Rational < Numeric
   #
   def negative?: () -> bool
 
-  def nonzero?: () -> self?
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.numerator  ->  integer
@@ -354,10 +316,6 @@ class Rational < Numeric
   #
   def numerator: () -> Integer
 
-  alias phase angle
-
-  def polar: () -> [ Rational, Integer | Float ]
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.positive?  ->  true or false
@@ -375,9 +333,7 @@ class Rational < Numeric
   #     Rational(9, 8)  / 4                #=> (9/32)
   #     Rational(20, 9) / 9.8              #=> 0.22675736961451246
   #
-  def quo: (Float) -> Float
-         | (Complex) -> Complex
-         | (Numeric) -> Rational
+  alias quo /
 
   # <!--
   #   rdoc-file=rational.c
@@ -392,18 +348,8 @@ class Rational < Numeric
   #     r.rationalize(Rational('0.01'))  #=> (3/10)
   #     r.rationalize(Rational('0.1'))   #=> (1/3)
   #
-  def rationalize: (?Numeric eps) -> Rational
-
-  def real: () -> Rational
-
-  def real?: () -> true
-
-  def rect: () -> [ Rational, Numeric ]
-
-  alias rectangular rect
-
-  def remainder: (Float) -> Float
-               | (Numeric) -> Rational
+  def rationalize: () -> self
+                 | (Numeric::_Eps eps) -> instance
 
   # <!--
   #   rdoc-file=rational.c
@@ -440,15 +386,8 @@ class Rational < Numeric
   #     Rational(-25, 100).round(1, half: :down) #=> (-1/5)
   #     Rational(-25, 100).round(1, half: :even) #=> (-1/5)
   #
-  def round: (?half: :up | :down | :even) -> Integer
-           | (Integer digits, ?half: :up | :down | :even) -> (Integer | Rational)
-
-  def step: (?Numeric limit, ?Numeric step) { (Rational) -> void } -> self
-          | (?Numeric limit, ?Numeric step) -> Enumerator[Rational, self]
-          | (?by: Numeric, ?to: Numeric) { (Rational) -> void } -> self
-          | (?by: Numeric, ?to: Numeric) -> Enumerator[Rational, self]
-
-  def to_c: () -> Complex
+  def round: (?half: Numeric::round_direction) -> Integer
+           | (Integer digits, ?half: Numeric::round_direction) -> (Integer | instance)
 
   # <!--
   #   rdoc-file=rational.c
@@ -479,8 +418,6 @@ class Rational < Numeric
   #
   def to_i: () -> Integer
 
-  alias to_int to_i
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.to_r  ->  self
@@ -490,7 +427,7 @@ class Rational < Numeric
   #     Rational(2).to_r      #=> (2/1)
   #     Rational(-8, 6).to_r  #=> (-4/3)
   #
-  def to_r: () -> Rational
+  def to_r: () -> self
 
   # <!--
   #   rdoc-file=rational.c
@@ -528,7 +465,110 @@ class Rational < Numeric
   #     Rational('-123.456').truncate(-1)       #=> -120
   #
   def truncate: () -> Integer
-              | (Integer ndigits) -> (Integer | Rational)
+              | (Integer digits) -> (Integer | instance)
+
+  private
 
+  # TODO: marshal functions??
+  public
+
+  %a{steep:deprecated}
+  def %: (Integer) -> Rational
+       | (Float) -> Float
+       | (Rational) -> Rational
+       | (Numeric) -> Numeric
+
+  %a{steep:deprecated}
+  def +@: () -> Rational
+
+  %a{steep:deprecated}
+  def abs2: () -> Rational
+
+  %a{steep:deprecated}
+  def angle: () -> (Integer | Float)
+
+  %a{steep:deprecated}
+  alias arg angle
+
+  %a{steep:deprecated}
+  def conj: () -> Rational
+
+  %a{steep:deprecated}
+  def conjugate: () -> Rational
+
+  %a{steep:deprecated}
+  def div: (Numeric) -> Integer
+
+  %a{steep:deprecated}
+  def divmod: (Numeric) -> [ Numeric, Numeric ]
+
+  %a{steep:deprecated}
+  def dup: () -> self
+
+  %a{steep:deprecated}
+  def eql?: (untyped) -> bool
+
+  %a{steep:deprecated}
+  def finite?: () -> bool
+
+  %a{steep:deprecated}
+  def i: () -> Complex
+
+  %a{steep:deprecated}
+  def imag: () -> Integer
+
+  %a{steep:deprecated}
+  def imaginary: () -> Integer
+
+  %a{steep:deprecated}
+  def infinite?: () -> Integer?
+
+  %a{steep:deprecated}
+  def integer?: () -> bool
+
+  %a{steep:deprecated}
+  def modulo: (Float) -> Float
+            | (Numeric) -> Rational
+
+  %a{steep:deprecated}
+  def nonzero?: () -> self?
+
+  %a{steep:deprecated}
+  alias phase angle
+
+  %a{steep:deprecated}
+  def polar: () -> [ Rational, Integer | Float ]
+
+  %a{steep:deprecated}
+  def real: () -> Rational
+
+  %a{steep:deprecated}
+  def real?: () -> true
+
+  %a{steep:deprecated}
+  def rect: () -> [ Rational, Numeric ]
+
+  %a{steep:deprecated}
+  alias rectangular rect
+
+  %a{steep:deprecated}
+  def remainder: (Float) -> Float
+               | (Numeric) -> Rational
+
+  %a{steep:deprecated}
+  def step: (?Numeric limit, ?Numeric step) { (Rational) -> void } -> self
+          | (?Numeric limit, ?Numeric step) -> Enumerator[Rational, self]
+          | (?by: Numeric, ?to: Numeric) { (Rational) -> void } -> self
+          | (?by: Numeric, ?to: Numeric) -> Enumerator[Rational, self]
+
+  %a{steep:deprecated}
+  def to_c: () -> Complex
+
+  %a{steep:deprecated}
+  alias to_int to_i
+
+  %a{steep:deprecated}
   def zero?: () -> bool
+
 end
+
diff --git a/test/stdlib/Rational_test.rb b/test/stdlib/Rational_test.rb
index 94573e14a..44bd17d55 100644
--- a/test/stdlib/Rational_test.rb
+++ b/test/stdlib/Rational_test.rb
@@ -1,198 +1,288 @@
-require_relative "test_helper"
+require_relative 'test_helper'
 
-class RationalTest < StdlibTest
-  target Rational
-
-  def test_calc
-    10r % 10
-    10r % 1.3
-    10r % 2r
+class RationalInstanceTest < Test::Unit::TestCase
+  include TestHelper
 
-    10r * 10
-    10r * 1.2
-    10r * 2r
-    10r * Complex.rect(1,2)
+  testing '::Rational'
+
+  class Subclass < Rational; end
+  class Subclass2 < Rational; end
+  INSTANCE = Class.instance_method(:new).bind_call(Subclass) + (1/2r)
+  INSTANCE2 = Class.instance_method(:new).bind_call(Subclass2) + (1/2r)
+
+  def test_mul
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :*, 3
+    assert_send_type  '(Rational) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :*, 1/2r
+    assert_send_type  '(Float) -> Float',
+                      INSTANCE, :*, 1.0
+
+    with_coercible :* do |coercible|
+      assert_send_type '[O < Numeric::_Multiply[S, R], R] (Numeric::_Coerce[Float, O, S] other) -> R',
+                       INSTANCE, :*, coercible
+    end
+  end
 
-    3r ** 2
-    3r ** 2.1
-    3r ** 2r
-    3r ** Complex.rect(1,2)
+  def test_pow
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :**, 3
+
+    assert_send_type  '(Rational) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :**, 1r
+    assert_send_type  '(Rational) -> Float',
+                      INSTANCE, :**, 1/2r
+    assert_send_type  '(Rational) -> Complex',
+                      -INSTANCE, :**, 1/2r
+
+    assert_send_type  '(Float) -> Float',
+                      INSTANCE, :**, 1.0
+    assert_send_type  '(Float) -> Complex',
+                      -INSTANCE, :**, 0.5
+
+    with_coercible :** do |coercible|
+      assert_send_type '[O < Numeric::_Power[S, R], R] (Numeric::_Coerce[Float, O, S] other) -> R',
+                       INSTANCE, :**, coercible
+    end
+  end
 
-    10r + 10
-    10r + 1.2
-    10r + 2r
-    10r + Complex.rect(1,2)
+  def test_add
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :+, 3
+    assert_send_type  '(Rational) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :+, 1/2r
+    assert_send_type  '(Float) -> Float',
+                      INSTANCE, :+, 0.0
+
+    with_coercible :+ do |coercible|
+      assert_send_type '[O < Numeric::_Add[S, R], R] (Numeric::_Coerce[Float, O, S] other) -> R',
+                       INSTANCE, :+, coercible
+    end
+  end
 
-    10r - 10
-    10r - 1.2
-    10r - 2r
-    10r - Complex.rect(1,2)
+  def test_sub
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :-, 3
+    assert_send_type  '(Rational) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :-, 1/2r
+    assert_send_type  '(Float) -> Float',
+                      INSTANCE, :-, 0.0
+
+    with_coercible :- do |coercible|
+      assert_send_type '[O < Numeric::_Subtract[S, R], R] (Numeric::_Coerce[Float, O, S] other) -> R',
+                       INSTANCE, :-, coercible
+    end
+  end
 
-    10r / 10
-    10r / 1.2
-    10r / 2r
-    10r / Complex.rect(1,2)
+  def test_uneg
+    assert_send_type  '() -> RationalInstanceTest::Subclass',
+                      INSTANCE, :-@
   end
 
-  def test_compare
-    10r <=> 1
-    10r < 1
-    10r <= 3r
-    10r > 3.1
-    10r >= Complex.rect(1,0)
+  def test_div(method: :/)
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, method, 3
+    assert_send_type  '(Rational) -> RationalInstanceTest::Subclass',
+                      INSTANCE, method, 1/2r
+    assert_send_type  '(Float) -> Float',
+                      INSTANCE, method, 1.0
+
+    with_coercible :/ do |coercible|
+      assert_send_type '[O < Numeric::_Divide[S, R], R] (Numeric::_Coerce[Float, O, S] other) -> R',
+                       INSTANCE, method, coercible
+    end
   end
 
-  def test_eq
-    a = 31r
+  def test_cmp
+    with 1, 0, 1/2r, 1/3r, INSTANCE do |other|
+      assert_send_type  '(Integer | Rational) -> (-1 | 0 | 1)',
+                        INSTANCE, :<=>, other
+    end
 
-    a == 1
-    a == Object.new
+    with_untyped.and INSTANCE do |untyped|
+      assert_send_type  '(untyped) -> (-1 | 0 | 1)?',
+                        INSTANCE, :<=>, untyped
+    end
   end
 
-  def test_abs
-    a = 31r
+  def test_eq
+    with_untyped.and INSTANCE do |untyped|
+      def untyped.==(other) = true unless defined?(untyped.==)
 
-    a.abs
-    a.abs2
+      assert_send_type  '(untyped) -> bool',
+                        INSTANCE, :==, untyped
+    end
   end
 
-  def test_angle
-    a = 31r
+  def test_abs(method: :abs)
+    assert_send_type  '() -> RationalInstanceTest::Subclass',
+                      INSTANCE, :abs
 
-    a.angle
-    a.arg
-    -a.phase
+    assert_send_type  '() -> RationalInstanceTest::Subclass',
+                      -INSTANCE, :abs
   end
 
   def test_ceil
-    a = 312r/5
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :ceil
 
-    a.ceil
-    a.ceil(3)
-    # a.ceil(ToInt.new) # does not accept to_int
-  end
+    assert_send_type  '(Integer) -> Integer',
+                      INSTANCE, :ceil, -1
 
-  def test_conj
-    a = 312r
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :ceil, 2
+  end
 
-    a.conj
-    a.conjugate
+  def test_coerce
+    assert_send_type  '(Integer) -> [RationalInstanceTest::Subclass, RationalInstanceTest::Subclass]',
+                      INSTANCE, :coerce, 1
+    assert_send_type  '(Float) -> [Float, Float]',
+                      INSTANCE, :coerce, 1.0
+    assert_send_type  '(RationalInstanceTest::Subclass2) -> [RationalInstanceTest::Subclass2, RationalInstanceTest::Subclass]',
+                      INSTANCE, :coerce, INSTANCE2
+    assert_send_type  '(Complex) -> [RationalInstanceTest::Subclass, RationalInstanceTest::Subclass]',
+                      INSTANCE, :coerce, 0i
+    assert_send_type  '(Complex) -> [Complex, Complex]',
+                      INSTANCE, :coerce, 1i
   end
 
   def test_denominator
-    a = 133r
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :denominator
+  end
 
-    a.denominator
+  def test_fdiv
+    assert_send_type  '(Integer) -> Float',
+                      INSTANCE, :fdiv, 1
+    assert_send_type  '(Rational) -> Float',
+                      INSTANCE, :fdiv, 1r
+    assert_send_type  '(Float) -> Float',
+                      INSTANCE, :fdiv, 1.0
+
+    return_value = BlankSlate.new
+    def return_value.to_f = 3.14
+    with_coercible :/, return_value: return_value do |coercible|
+      assert_send_type '[O < Numeric::_Divide[S, R], R < _ToF] (Numeric::_Coerce[Float, O, S] other) -> R',
+                       INSTANCE, :fdiv, coercible
+    end
   end
 
-  def test_div
-    a = 123r
+  def test_floor
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :floor
 
-    a.div(3)
-    a.div(3.1)
-    a.div(12r)
+    assert_send_type  '(Integer) -> Integer',
+                      INSTANCE, :floor, -1
 
-    a.divmod(3)
-    a.divmod(3.1)
-    a.divmod(1r/5)
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :floor, 2
   end
 
-  def test_fdiv
-    a = 3r/2
-
-    a.fdiv(3)
-    a.fdiv(3.1)
-    a.fdiv(1r/3)
+  def test_hash
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :hash
   end
 
-  def test_floor
-    a = 3r/2
+  def test_inspect
+    assert_send_type  '() -> String',
+                      INSTANCE, :inspect
+  end
 
-    a.floor()
-    a.floor(-1)
-    # a.floor(ToInt.new) # No to_int support
+  def test_magnitude
+    test_abs(method: :magnitude)
   end
 
-  def test_modulo
-    a = 3r/2
+  def test_negative?
+    assert_send_type  '() -> bool',
+                      INSTANCE, :negative?
 
-    a.modulo(2)
-    a.modulo(1.1)
-    a.modulo(a)
+    assert_send_type  '() -> bool',
+                      -INSTANCE, :negative?
   end
 
   def test_numerator
-    a = 3r/2
-
-    a.numerator
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :denominator
   end
 
-  def test_polar
-    31r.polar
-    (-31r/2).polar
+  def test_positive?
+    assert_send_type  '() -> bool',
+                      INSTANCE, :positive?
+
+    assert_send_type  '() -> bool',
+                      -INSTANCE, :positive?
   end
 
   def test_quo
-    a = 1/11r
-
-    a.quo(3)
-    a.quo(1.3)
-    a.quo(1r/3)
-    a.quo(Complex.rect(1,2))
+    test_div(method: :quo)
   end
 
   def test_rationalize
-    a = 14r
-
-    a.rationalize
-    a.rationalize(3.11)
-  end
+    assert_send_type  '() -> RationalInstanceTest::Subclass',
+                      INSTANCE, :rationalize
 
-  def test_reminder
-    a = 14r
+    eps = BlankSlate.new
+    def eps.abs = 1.2
 
-    a.remainder(3)
-    a.remainder(3.1)
-    a.remainder(3r/5)
+    assert_send_type  '(Numeric::_Eps) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :rationalize, eps 
   end
 
   def test_round
-    a = 1r/3
-
-    a.round(half: :up)
-    a.round(2, half: :up)
-    # a.round(ToInt.new(-2), half: :up) # to_int not supported
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :round
+
+    assert_send_type  '(Integer) -> Integer',
+                      INSTANCE, :round, -1
+
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :round, 2
+
+    with(:up, :down, :even, nil).and with_string('up'), with_string('down'), with_string('even') do |dir|
+      unless defined?(dir.==)
+        def dir.==(rhs) = rhs == to_str
+      end
+
+      assert_send_type  '(half: Numeric::round_direction) -> Integer',
+                        INSTANCE, :round, half: dir
+      assert_send_type  '(half: Numeric::round_direction) -> Integer',
+                        INSTANCE, :round, half: dir
+
+      assert_send_type  '(Integer, half: Numeric::round_direction) -> Integer',
+                        INSTANCE, :round, -1, half: dir
+      assert_send_type  '(Integer, half: Numeric::round_direction) -> RationalInstanceTest::Subclass',
+                        INSTANCE, :round, 2, half: dir
+     end
   end
 
-  def test_step
-    a = 1r/3
+  def test_to_f
+    assert_send_type  '() -> Float',
+                      INSTANCE, :to_f
+  end
 
-    a.step { break }
-    a.step(1, 2) { }
-    a.step(by: 3, to: 100) { }
+  def test_to_i
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :to_i
   end
 
-  def test_truncate
-    a = 1r/3
+  def test_to_r
+    assert_send_type  '() -> RationalInstanceTest::Subclass',
+                      INSTANCE, :to_r
+  end
 
-    a.truncate
-    a.truncate(1)
+  def test_to_s
+    assert_send_type  '() -> String',
+                      INSTANCE, :to_s
   end
-end
 
-class RationalInstanceTest < Test::Unit::TestCase
-  include TestHelper
+  def test_truncate
+    assert_send_type  '() -> Integer',
+                      INSTANCE, :truncate
+
+    assert_send_type  '(Integer) -> Integer',
+                      INSTANCE, :truncate, -1
 
-  testing "::Rational"
-
-  def test_multiply
-    assert_send_type "(Integer) -> Rational",
-                      1r, :*, 1
-    assert_send_type "(Rational) -> Rational",
-                      1r, :*, 1r
-    assert_send_type "(Float) -> Float",
-                      1r, :*, 3.1
-    assert_send_type "(Complex) -> Complex",
-                      1, :*, Complex.rect(1,2)
+    assert_send_type  '(Integer) -> RationalInstanceTest::Subclass',
+                      INSTANCE, :truncate, 2
   end
 end
diff --git a/test/stdlib/test_helper.rb b/test/stdlib/test_helper.rb
index 1f23d3478..91508c631 100644
--- a/test/stdlib/test_helper.rb
+++ b/test/stdlib/test_helper.rb
@@ -79,6 +79,22 @@ def with_timeout(seconds: 1, nanoseconds: 0)
       end
     end
   end
+
+  def with_coercible(method, return_value: :hello)
+    equivself = Struct.new(:equiv_self)
+    equivother = Struct.new(:equiv_other) do
+      define_method(method) do |other|
+        fail unless equivself === other
+        return_value
+      end
+    end
+
+    yield Class.new{
+      define_method(:coerce) do |float|
+        [equivother.new(float), equivself.new(self)]
+      end
+    }.new
+  end
 end
 
 class Writer