diff --git a/core/numeric.rbs b/core/numeric.rbs
index f81b4c79d..7fe7595c6 100644
--- a/core/numeric.rbs
+++ b/core/numeric.rbs
@@ -161,6 +161,11 @@ class Numeric
   # The direction you can round
   type round_mode = :up | :down | :even | 'up' | 'down' | 'even' | string | nil
 
+  # An interface that indicates a type can be coerced.
+  interface _Coerce[O, Other, Self]
+    def coerce: (O other) -> [Other, Self]
+  end
+
   # <!--
   #   rdoc-file=numeric.c
   #   - self % other -> real_numeric
diff --git a/core/rational.rbs b/core/rational.rbs
index 5abca095e..eb6808037 100644
--- a/core/rational.rbs
+++ b/core/rational.rbs
@@ -64,9 +64,9 @@ class Rational < Numeric
   #     Rational(900)   * Rational(1)     #=> (900/1)
   #     Rational(-2, 9) * Rational(-9, 2) #=> (1/1)
   #
-  def *: (Integer) -> Rational
-       | (Rational) -> Rational
-       | [T < Numeric](T) -> T
+  def *: (Integer | Rational other) -> instance
+       | (Float other) -> Float
+       | [S, R] (Numeric::_Coerce[self, RBS::Ops::_Times[S, R], S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -81,8 +81,13 @@ class Rational < Numeric
   #     Rational(1, 2) ** 0               #=> (1/1)
   #     Rational(1, 2) ** 0.0             #=> 1.0
   #
-  def **: (Complex) -> Complex
-        | (Numeric) -> Numeric
+  def **: (Integer exponent) -> instance
+        | (Rational exponent) -> (instance | Float | Complex) # `instance` only for special-cases like `**0r`
+        | (Float exponent) -> (Float | Complex)
+        | (Complex exponent) -> (instance | Complex) # instance only for special-cases like `**0i`
+        | [S, R] ((Numeric & Numeric::_Coerce[self, RBS::Ops::_Power[S, R], S]) other) -> (R | Rational)
+        | [S, R] (Numeric::_Coerce[self, RBS::Ops::_Power[S, R], S] other) -> R
+
 
   # <!--
   #   rdoc-file=rational.c
@@ -106,9 +111,9 @@ class Rational < Numeric
   #     Rational(2, 3) + 1.0 # => 1.6666666666666665
   #     Rational(2, 3) + Complex(1.0, 0.0) # => (1.6666666666666665+0.0i)
   #
-  def +: (Float) -> Float
-       | (Complex) -> Complex
-       | (Numeric) -> Rational
+  def +: (Integer | Rational other) -> instance
+       | (Float other) -> Float
+       | [S, R] (Numeric::_Coerce[self, RBS::Ops::_Add[S, R], S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -122,9 +127,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
+       | [S, R] (Numeric::_Coerce[self, RBS::Ops::_Subtract[S, R], S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -135,7 +140,7 @@ class Rational < Numeric
   #     -(1/3r)   # => (-1/3)
   #     -(-1/3r)  # => (1/3)
   #
-  def -@: () -> Rational
+  def -@: () -> instance
 
   # <!--
   #   rdoc-file=rational.c
@@ -149,9 +154,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
+       | [S, R] (Numeric::_Coerce[self, RBS::Ops::_Divide[S, R], S] other) -> R
 
   # <!--
   #   rdoc-file=rational.c
@@ -179,8 +184,8 @@ class Rational < Numeric
   # Class Rational includes module Comparable, each of whose methods uses
   # Rational#<=> for comparison.
   #
-  def <=>: (Integer | Rational) -> Integer
-         | (untyped) -> Integer?
+  def <=>: (Integer | Rational other) -> (-1 | 0 | 1)
+         | (untyped other) -> Integer?
 
   # <!--
   #   rdoc-file=rational.c
@@ -194,7 +199,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
@@ -206,7 +211,7 @@ class Rational < Numeric
   #     (1/2r).abs    #=> (1/2)
   #     (-1/2r).abs   #=> (1/2)
   #
-  def abs: () -> Rational
+  def abs: () -> instance
 
   # <!--
   #   rdoc-file=rational.c
@@ -232,9 +237,11 @@ class Rational < Numeric
   #     Rational('-123.456').ceil(-1)       #=> -120
   #
   def ceil: () -> Integer
-          | (Integer digits) -> (Integer | Rational)
+          | (Integer ndigits) -> (Integer | instance)
 
-  def coerce: (Numeric) -> [ Numeric, Numeric ]
+  def coerce: (Integer | Rational other) -> [ instance, self ]
+            | (Float other) -> [ Float, Float ]
+            | (Complex other) -> ([ Complex, Complex ] | [ instance, self ])
 
   # <!--
   #   rdoc-file=rational.c
@@ -262,7 +269,8 @@ class Rational < Numeric
   #     Rational(2, 3).fdiv(0.5)     #=> 1.3333333333333333
   #     Rational(2).fdiv(3)          #=> 0.6666666666666666
   #
-  def fdiv: (Numeric) -> Float
+  def fdiv: (Integer | Rational | Float | Complex other) -> Float
+          | [S] ((Numeric::_Coerce[self, RBS::Ops::_Times[S, _ToF], S] & RBS::Ops::_Equal[0]) other) -> Float
 
   # <!--
   #   rdoc-file=rational.c
@@ -288,7 +296,7 @@ class Rational < Numeric
   #     Rational('-123.456').floor(-1)       #=> -130
   #
   def floor: () -> Integer
-           | (Integer digits) -> (Integer | Rational)
+           | (Integer ndigits) -> (Integer | instance)
 
   # <!--
   #   rdoc-file=rational.c
@@ -360,9 +368,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
@@ -377,7 +383,8 @@ class Rational < Numeric
   #     r.rationalize(Rational('0.01'))  #=> (3/10)
   #     r.rationalize(Rational('0.1'))   #=> (1/3)
   #
-  def rationalize: (?Numeric eps) -> Rational
+  def rationalize: () -> self
+                | (Numeric eps) -> instance # technically has a more specific one, but it yields a segfault.
 
   def rect: () -> [ Rational, Numeric ]
 
@@ -419,8 +426,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 round: (?half: Numeric::round_mode) -> Integer
+           | (Integer digits, ?half: Numeric::round_mode) -> (Integer | Rational)
 
   # <!--
   #   rdoc-file=rational.c
@@ -460,7 +467,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
@@ -498,5 +505,7 @@ class Rational < Numeric
   #     Rational('-123.456').truncate(-1)       #=> -120
   #
   def truncate: () -> Integer
-              | (Integer ndigits) -> (Integer | Rational)
+              | (Integer ndigits) -> (Integer | instance)
+
+  private def marshal_dump: () -> [ Integer, Integer ]
 end
diff --git a/test/stdlib/Rational_test.rb b/test/stdlib/Rational_test.rb
index 6dba75f70..5d18e9d4c 100644
--- a/test/stdlib/Rational_test.rb
+++ b/test/stdlib/Rational_test.rb
@@ -1,191 +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
-
-    10r * 10
-    10r * 1.2
-    10r * 2r
-    10r * Complex.rect(1,2)
-
-    3r ** 2
-    3r ** 2.1
-    3r ** 2r
-    3r ** Complex.rect(1,2)
+class RationalInstanceTest < Test::Unit::TestCase
+  include TestHelper
 
-    10r + 10
-    10r + 1.2
-    10r + 2r
-    10r + Complex.rect(1,2)
+  testing 'Rational'
+
+  def test_op_mul
+    assert_send_type  '(Integer) -> Rational',
+                      3/8r, :*, 38
+    assert_send_type  '(Rational) -> Rational',
+                      3/8r, :*, -9/13r
+    assert_send_type  '(Float) -> Float',
+                      3/8r, :*, 12.34
+    assert_send_type  '(Complex) -> Complex',
+                      3/8r, :*, 12-34i
+    assert_send_type  '(Coercable) -> Coercable::OpReturn',
+                      3/8r, :*, Coercable.for_op(:*)
+  end
 
-    10r - 10
-    10r - 1.2
-    10r - 2r
-    10r - Complex.rect(1,2)
+  class MyZeroNumeric < Numeric
+    def ==(other) = 0 == other ? true : super
+  end
 
-    10r / 10
-    10r / 1.2
-    10r / 2r
-    10r / Complex.rect(1,2)
+  def test_op_pow
+    # Technically, the rational code for `**` has a branch for integer exponents when `Integer#**`
+    # returns `Float`. That's no longer a thing (now that `exponent is too large` is raised), so the
+    # branch is dead code
+    assert_send_type  '(Integer) -> Rational',
+                      3/8r, :**, 24
+
+    assert_send_type  '(Rational) -> Rational',
+                      3/8r, :**, 0r
+    assert_send_type  '(Rational) -> Float',
+                      3/8r, :**, 1/2r
+    assert_send_type  '(Rational) -> Complex',
+                      -3/8r, :**, 1/2r
+
+    assert_send_type  '(Float) -> Float',
+                      3/8r, :**, 0.0
+    assert_send_type  '(Float) -> Float',
+                      3/8r, :**, 0.5
+    assert_send_type  '(Float) -> Complex',
+                      -3/8r, :**, 0.5
+
+    assert_send_type  '(Complex) -> Rational',
+                      3/8r, :**, 0i
+    assert_send_type  '(Complex) -> Complex',
+                      3/8r, :**, 0.5+0i
+    assert_send_type  '(Complex) -> Complex',
+                      -3/8r, :**, 0.5i
+
+    assert_send_type  '(RationalInstanceTest::MyZeroNumeric) -> Rational',
+                      3/8r, :**, MyZeroNumeric.new
+    assert_send_type  '(Coercable) -> Coercable::OpReturn',
+                      3/8r, :**, Coercable.for_op(:**)
   end
 
-  def test_compare
-    10r <=> 1
-    10r < 1
-    10r <= 3r
-    10r > 3.1
-    10r >= Complex.rect(1,0)
+  def test_op_add
+    assert_send_type  '(Integer) -> Rational',
+                      3/8r, :+, 38
+    assert_send_type  '(Rational) -> Rational',
+                      3/8r, :+, -9/13r
+    assert_send_type  '(Float) -> Float',
+                      3/8r, :+, 12.34
+    assert_send_type  '(Complex) -> Complex',
+                      3/8r, :+, 12-34i
+    assert_send_type  '(Coercable) -> Coercable::OpReturn',
+                      3/8r, :+, Coercable.for_op(:+)
   end
 
-  def test_eq
-    a = 31r
+  def test_op_sub
+    assert_send_type  '(Integer) -> Rational',
+                      3/8r, :-, 38
+    assert_send_type  '(Rational) -> Rational',
+                      3/8r, :-, -9/13r
+    assert_send_type  '(Float) -> Float',
+                      3/8r, :-, 12.34
+    assert_send_type  '(Complex) -> Complex',
+                      3/8r, :-, 12-34i
+    assert_send_type  '(Coercable) -> Coercable::OpReturn',
+                      3/8r, :-, Coercable.for_op(:-)
+  end
 
-    a == 1
-    a == Object.new
+  def test_op_uneg
+    assert_send_type  '() -> Rational',
+                      3/8r, :-@
   end
 
-  def test_abs
-    a = 31r
+  def test_op_div(method: :/)
+    assert_send_type  '(Integer) -> Rational',
+                      3/8r, method, 38
+    assert_send_type  '(Rational) -> Rational',
+                      3/8r, method, -9/13r
+    assert_send_type  '(Float) -> Float',
+                      3/8r, method, 12.34
+    assert_send_type  '(Complex) -> Complex',
+                      3/8r, method, 12-34i
+    assert_send_type  '(Coercable) -> Coercable::OpReturn',
+                      3/8r, method, Coercable.for_op(:/) # note not `.for_op(method)`
+  end
 
-    a.abs
-    a.abs2
+  def test_op_cmp
+    with -3, 0, 4, 5 do |num|
+      assert_send_type  '(Integer) -> (-1 | 0 | 1)',
+                        4/1r, :<=>, num
+      assert_send_type  '(Rational) -> (-1 | 0 | 1)',
+                        4/1r, :<=>, num.to_r
+    end
+
+    with_untyped.and 2, 3.4, 5/6r, 7+8i do |untyped|
+      assert_send_type  '(untyped) -> Integer?',
+                        3/8r, :<=>, untyped
+    end
   end
 
-  def test_angle
-    a = 31r
+  def test_op_eq
+    with_untyped.and 2, 2.0, 2r, 2+0i do |untyped|
+      next unless defined? untyped.==
+      assert_send_type  '(untyped) -> bool',
+                        2/1r, :==, untyped
+    end
+  end
 
-    a.angle
-    a.arg
-    -a.phase
+  def test_abs(method: :abs)
+    assert_send_type  '() -> Rational',
+                      3/8r, method
+    assert_send_type  '() -> Rational',
+                      -3/8r, method
   end
 
   def test_ceil
-    a = 312r/5
-
-    a.ceil
-    a.ceil(3)
-    # a.ceil(ToInt.new) # does not accept to_int
+    assert_send_type  '() -> Integer',
+                      38/3r, :ceil
+    assert_send_type  '(Integer) -> Rational',
+                      38/3r, :ceil, 2
+    assert_send_type  '(Integer) -> Integer',
+                      38/3r, :ceil, -2
   end
 
-  def test_denominator
-    a = 133r
-
-    a.denominator
+  def test_coerce
+    assert_send_type  '(Integer) -> [Rational, Rational]',
+                      3/8r, :coerce, 12
+    assert_send_type  '(Rational) -> [Rational, Rational]',
+                      3/8r, :coerce, -9/13r
+    assert_send_type  '(Float) -> [Float, Float]',
+                      3/8r, :coerce, 3.4
+    assert_send_type  '(Complex) -> [Complex, Complex]',
+                      3/8r, :coerce, 1+2i
+    assert_send_type  '(Complex) -> [Rational, Rational]',
+                      3/8r, :coerce, 1.2+0i
   end
 
-  def test_div
-    a = 123r
-
-    a.div(3)
-    a.div(3.1)
-    a.div(12r)
-
-    a.divmod(3)
-    a.divmod(3.1)
-    a.divmod(1r/5)
+  def test_denominator
+    assert_send_type  '() -> Integer',
+                      3/8r, :denominator
   end
 
   def test_fdiv
-    a = 3r/2
-
-    a.fdiv(3)
-    a.fdiv(3.1)
-    a.fdiv(1r/3)
+    assert_send_type  '(Integer) -> Float',
+                      3/8r, :fdiv, 12
+    assert_send_type  '(Rational) -> Float',
+                      3/8r, :fdiv, 12r
+    assert_send_type  '(Float) -> Float',
+                      3/8r, :fdiv, 1.2
+    assert_send_type  '(Complex) -> Float',
+                      3/8r, :fdiv, 2+0i
+
+    with_float 3.4 do |float|
+      coerce = Coercable.for_op(:/, result: float)
+      def coerce.==(r) = false
+      assert_send_type  '(Coercable) -> Float',
+                        3/8r, :fdiv, coerce
+    end
   end
 
   def test_floor
-    a = 3r/2
+    assert_send_type  '() -> Integer',
+                      38/3r, :floor
+    assert_send_type  '(Integer) -> Rational',
+                      38/3r, :floor, 2
+    assert_send_type  '(Integer) -> Integer',
+                      38/3r, :floor, -2
+  end
 
-    a.floor()
-    a.floor(-1)
-    # a.floor(ToInt.new) # No to_int support
+  def test_hash
+    assert_send_type  '() -> Integer',
+                      3/8r, :hash
   end
 
-  def test_modulo
-    a = 3r/2
+  def test_inspect
+    assert_send_type  '() -> String',
+                      3/8r, :inspect
+  end
 
-    a.modulo(2)
-    a.modulo(1.1)
-    a.modulo(a)
+  def test_magnitude
+    test_abs(method: :magnitude)
   end
 
-  def test_numerator
-    a = 3r/2
+  def test_negative?
+    assert_send_type  '() -> bool',
+                      3/8r, :negative?
+    assert_send_type  '() -> bool',
+                      -3/8r, :negative?
+  end
 
-    a.numerator
+  def test_numerator
+    assert_send_type  '() -> Integer',
+                      3/8r, :numerator
   end
 
-  def test_polar
-    31r.polar
-    (-31r/2).polar
+  def test_positive?
+    assert_send_type  '() -> bool',
+                      3/8r, :positive?
+    assert_send_type  '() -> bool',
+                      -3/8r, :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_op_div(method: :quo)
   end
 
   def test_rationalize
-    a = 14r
+    assert_send_type  '() -> Rational',
+                      3/8r, :rationalize
 
-    a.rationalize
-    a.rationalize(3.11)
+    with 1, 1/5r, 0.001, 0.000004+0i do |eps|
+      assert_send_type  '(Numeric) -> Rational',
+                        3/8r, :rationalize, eps
+    end
   end
 
-  def test_reminder
-    a = 14r
+  def test_round
+    assert_send_type  '() -> Integer',
+                      7/2r, :round
+
+    with_round_mode do |mode|
+      assert_send_type  '(half: Numeric::round_mode) -> Integer',
+                        7/2r, :round, half: mode
+    end
 
-    a.remainder(3)
-    a.remainder(3.1)
-    a.remainder(3r/5)
+    assert_send_type  '(Integer) -> Integer',
+                      7/2r, :round, -1
+
+    with_round_mode do |mode|
+      assert_send_type  '(Integer, half: Numeric::round_mode) -> Integer',
+                        7/2r, :round, -1, half: mode
+    end
   end
 
-  def test_round
-    a = 1r/3
+  def test_to_f
+    assert_send_type  '() -> Float',
+                      3/8r, :to_f
+  end
 
-    a.round(half: :up)
-    a.round(2, half: :up)
-    # a.round(ToInt.new(-2), half: :up) # to_int not supported
+  def test_to_i
+    assert_send_type  '() -> Integer',
+                      3/8r, :to_i
+    assert_send_type  '() -> Integer',
+                      -38/8r, :to_i
   end
 
-  def test_step
-    a = 1r/3
+  def test_to_r
+    assert_send_type  '() -> Rational',
+                      3/8r, :to_r
+  end
 
-    a.step { break }
-    a.step(1, 2) { }
-    a.step(by: 3, to: 100) { }
+  def test_to_s
+    assert_send_type  '() -> String',
+                      3/8r, :to_s
   end
 
   def test_truncate
-    a = 1r/3
-
-    a.truncate
-    a.truncate(1)
+    assert_send_type  '() -> Integer',
+                      38/3r, :truncate
+    assert_send_type  '(Integer) -> Rational',
+                      38/3r, :truncate, 2
+    assert_send_type  '(Integer) -> Integer',
+                      38/3r, :truncate, -2
   end
-end
 
-class RationalInstanceTest < Test::Unit::TestCase
-  include TestHelper
+  def test_marshal_dump
+    assert_visibility :private, :marshal_dump
 
-  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, Integer]',
+                      3/8r, :marshal_dump
   end
 end
diff --git a/test/stdlib/test_helper.rb b/test/stdlib/test_helper.rb
index e9848e69c..30eab1952 100644
--- a/test/stdlib/test_helper.rb
+++ b/test/stdlib/test_helper.rb
@@ -80,6 +80,43 @@ def with_timeout(seconds: 1, nanoseconds: 0)
   end
 end
 
+class Coercable < RBS::UnitTest::Convertibles::BlankSlate
+  class OpReturn < ::RBS::UnitTest::Convertibles::BlankSlate
+  end
+
+  class CoerceOther < ::RBS::UnitTest::Convertibles::BlankSlate
+    attr_reader :__value__
+    def initialize(value) = @__value__ = value
+  end
+
+  class CoerceSelf < ::RBS::UnitTest::Convertibles::BlankSlate
+    def initialize(method, &block)
+      ::Kernel.instance_method(:define_singleton_method).bind_call(self, method, &block)
+    end
+  end
+
+  def self.for_op(method, result: noresult = true, &block)
+    if block_given?
+      unless noresult
+        raise ArgumentError, "cannot provide both a block and a result"
+      end
+    else
+      block = proc { |other| noresult ? OpReturn.new : result }
+    end
+
+    new(CoerceSelf.new(method, &block)) { |x| CoerceOther.new(x) }
+  end
+
+  def initialize(self_ret, &converter)
+    @self_ret = self_ret
+    @converter = converter || ->(x) { x }
+  end
+
+  def coerce(rhs)
+    [@self_ret, @converter.(rhs)]
+  end
+end
+
 class Writer
   attr_reader :buffer