rbs 3.6.1 → 3.9.5

data/core/basic_object.rbs

@@ -1,49 +1,44 @@
 # <!-- rdoc-file=object.c -->
-# BasicObject is the parent class of all classes in Ruby.  It's an explicit
-# blank class.
+# `BasicObject` is the parent class of all classes in Ruby. In particular,
+# `BasicObject` is the parent class of class Object, which is itself the default
+# parent class of every Ruby class:
 #
-# BasicObject can be used for creating object hierarchies independent of Ruby's
-# object hierarchy, proxy objects like the Delegator class, or other uses where
-# namespace pollution from Ruby's methods and classes must be avoided.
+#     class Foo; end
+#     Foo.superclass    # => Object
+#     Object.superclass # => BasicObject
 #
-# To avoid polluting BasicObject for other users an appropriately named subclass
-# of BasicObject should be created instead of directly modifying BasicObject:
+# `BasicObject` is the only class that has no parent:
 #
-#     class MyObjectSystem < BasicObject
-#     end
+#     BasicObject.superclass # => nil
 #
-# BasicObject does not include Kernel (for methods like `puts`) and BasicObject
-# is outside of the namespace of the standard library so common classes will not
-# be found without using a full class path.
+# Class `BasicObject` can be used to create an object hierarchy (e.g., class
+# Delegator) that is independent of Ruby's object hierarchy. Such objects:
 #
-# A variety of strategies can be used to provide useful portions of the standard
-# library to subclasses of BasicObject.  A subclass could `include Kernel` to
-# obtain `puts`, `exit`, etc.  A custom Kernel-like module could be created and
-# included or delegation can be used via #method_missing:
+# *   Do not have namespace "pollution" from the many methods provided in class
+#     Object and its included module Kernel.
+# *   Do not have definitions of common classes, and so references to such
+#     common classes must be fully qualified (`::String`, not `String`).
 #
-#     class MyObjectSystem < BasicObject
-#       DELEGATE = [:puts, :p]
+# A variety of strategies can be used to provide useful portions of the Standard
+# Library in subclasses of `BasicObject`:
 #
-#       def method_missing(name, *args, &block)
-#         return super unless DELEGATE.include? name
-#         ::Kernel.send(name, *args, &block)
-#       end
+# *   The immediate subclass could `include Kernel`, which would define methods
+#     such as `puts`, `exit`, etc.
+# *   A custom Kernel-like module could be created and included.
+# *   Delegation can be used via #method_missing:
 #
-#       def respond_to_missing?(name, include_private = false)
-#         DELEGATE.include?(name) or super
-#       end
-#     end
+#         class MyObjectSystem < BasicObject
+#           DELEGATE = [:puts, :p]
 #
-# Access to classes and modules from the Ruby standard library can be obtained
-# in a BasicObject subclass by referencing the desired constant from the root
-# like `::File` or `::Enumerator`. Like #method_missing, #const_missing can be
-# used to delegate constant lookup to `Object`:
+#           def method_missing(name, *args, &block)
+#             return super unless DELEGATE.include? name
+#             ::Kernel.send(name, *args, &block)
+#           end
 #
-#     class MyObjectSystem < BasicObject
-#       def self.const_missing(name)
-#         ::Object.const_get(name)
-#       end
-#     end
+#           def respond_to_missing?(name, include_private = false)
+#             DELEGATE.include?(name)
+#           end
+#         end
 #
 # ### What's Here
 #
@@ -60,6 +55,14 @@
 #     `self`.
 # *   #instance_exec: Executes the given block in the context of `self`, passing
 #     the given arguments.
+# *   #method_missing: Called when `self` is called with a method it does not
+#     define.
+# *   #singleton_method_added: Called when a singleton method is added to
+#     `self`.
+# *   #singleton_method_removed: Called when a singleton method is removed from
+#     `self`.
+# *   #singleton_method_undefined: Called when a singleton method is undefined
+#     in `self`.
 #
 class BasicObject
   # <!--

data/core/comparable.rbs

@@ -38,7 +38,7 @@
 #
 # ## What's Here
 #
-# Module Comparable provides these methods, all of which use method `<=>`:
+# Module Comparable provides these methods, all of which use method `#<=>`:
 #
 # *   #<: Returns whether `self` is less than the given object.
 # *   #<=: Returns whether `self` is less than or equal to the given object.

data/core/complex.rbs

@@ -6,35 +6,33 @@
 #
 # The rectangular coordinates of a complex number are called the *real* and
 # *imaginary* parts; see [Complex number
-# definition](https://en.wikipedia.org/wiki/Complex_number#Definition).
+# definition](https://en.wikipedia.org/wiki/Complex_number#Definition_and_basic_
+# operations).
 #
 # You can create a Complex object from rectangular coordinates with:
 #
-# *   A [complex literal](rdoc-ref:doc/syntax/literals.rdoc@Complex+Literals).
+# *   A [complex literal](rdoc-ref:syntax/literals.rdoc@Complex+Literals).
 # *   Method Complex.rect.
 # *   Method Kernel#Complex, either with numeric arguments or with certain
 #     string arguments.
 # *   Method String#to_c, for certain strings.
 #
-#
 # Note that each of the stored parts may be a an instance one of the classes
 # Complex, Float, Integer, or Rational; they may be retrieved:
 #
 # *   Separately, with methods Complex#real and Complex#imaginary.
 # *   Together, with method Complex#rect.
 #
-#
 # The corresponding (computed) polar values may be retrieved:
 #
 # *   Separately, with methods Complex#abs and Complex#arg.
 # *   Together, with method Complex#polar.
 #
-#
 # ## Polar Coordinates
 #
 # The polar coordinates of a complex number are called the *absolute* and
 # *argument* parts; see [Complex polar
-# plane](https://en.wikipedia.org/wiki/Complex_number#Polar_complex_plane).
+# plane](https://en.wikipedia.org/wiki/Complex_number#Polar_form).
 #
 # In this class, the argument part in expressed
 # [radians](https://en.wikipedia.org/wiki/Radian) (not
@@ -46,19 +44,94 @@
 # *   Method Kernel#Complex, with certain string arguments.
 # *   Method String#to_c, for certain strings.
 #
-#
 # Note that each of the stored parts may be a an instance one of the classes
 # Complex, Float, Integer, or Rational; they may be retrieved:
 #
 # *   Separately, with methods Complex#abs and Complex#arg.
 # *   Together, with method Complex#polar.
 #
-#
 # The corresponding (computed) rectangular values may be retrieved:
 #
 # *   Separately, with methods Complex#real and Complex#imag.
 # *   Together, with method Complex#rect.
 #
+# ## What's Here
+#
+# First, what's elsewhere:
+#
+# *   Class Complex inherits (directly or indirectly) from classes
+#     [Numeric](rdoc-ref:Numeric@What-27s+Here) and
+#     [Object](rdoc-ref:Object@What-27s+Here).
+# *   Includes (indirectly) module
+#     [Comparable](rdoc-ref:Comparable@What-27s+Here).
+#
+# Here, class Complex has methods for:
+#
+# ### Creating Complex Objects
+#
+# *   ::polar: Returns a new Complex object based on given polar coordinates.
+# *   ::rect (and its alias ::rectangular): Returns a new Complex object based
+#     on given rectangular coordinates.
+#
+# ### Querying
+#
+# *   #abs (and its alias #magnitude): Returns the absolute value for `self`.
+# *   #arg (and its aliases #angle and #phase): Returns the argument (angle) for
+#     `self` in radians.
+# *   #denominator: Returns the denominator of `self`.
+# *   #finite?: Returns whether both `self.real` and `self.image` are finite.
+# *   #hash: Returns the integer hash value for `self`.
+# *   #imag (and its alias #imaginary): Returns the imaginary value for `self`.
+# *   #infinite?: Returns whether `self.real` or `self.image` is infinite.
+# *   #numerator: Returns the numerator of `self`.
+# *   #polar: Returns the array `[self.abs, self.arg]`.
+# *   #inspect: Returns a string representation of `self`.
+# *   #real: Returns the real value for `self`.
+# *   #real?: Returns `false`; for compatibility with Numeric#real?.
+# *   #rect (and its alias #rectangular): Returns the array `[self.real,
+#     self.imag]`.
+#
+# ### Comparing
+#
+# *   #<=>: Returns whether `self` is less than, equal to, or greater than the
+#     given argument.
+# *   #==: Returns whether `self` is equal to the given argument.
+#
+# ### Converting
+#
+# *   #rationalize: Returns a Rational object whose value is exactly or
+#     approximately equivalent to that of `self.real`.
+# *   #to_c: Returns `self`.
+# *   #to_d: Returns the value as a BigDecimal object.
+# *   #to_f: Returns the value of `self.real` as a Float, if possible.
+# *   #to_i: Returns the value of `self.real` as an Integer, if possible.
+# *   #to_r: Returns the value of `self.real` as a Rational, if possible.
+# *   #to_s: Returns a string representation of `self`.
+#
+# ### Performing Complex Arithmetic
+#
+# *   #*: Returns the product of `self` and the given numeric.
+# *   #**: Returns `self` raised to power of the given numeric.
+# *   #+: Returns the sum of `self` and the given numeric.
+# *   #-: Returns the difference of `self` and the given numeric.
+# *   #-@: Returns the negation of `self`.
+# *   #/: Returns the quotient of `self` and the given numeric.
+# *   #abs2: Returns square of the absolute value (magnitude) for `self`.
+# *   #conj (and its alias #conjugate): Returns the conjugate of `self`.
+# *   #fdiv: Returns `Complex.rect(self.real/numeric, self.imag/numeric)`.
+#
+# ### Working with JSON
+#
+# *   ::json_create: Returns a new Complex object, deserialized from the given
+#     serialized hash.
+# *   #as_json: Returns a serialized hash constructed from `self`.
+# *   #to_json: Returns a JSON string representing `self`.
+#
+# These methods are provided by the [JSON gem](https://github.com/ruby/json). To
+# make these methods available:
+#
+#     require 'json/add/complex'
+#
 class Complex < Numeric
   # <!--
   #   rdoc-file=complex.c
@@ -115,11 +188,11 @@ class Complex < Numeric
   # -->
   # Returns the product of `self` and `numeric`:
   #
-  #     Complex(2, 3)  * Complex(2, 3)  # => (-5+12i)
-  #     Complex(900)   * Complex(1)     # => (900+0i)
-  #     Complex(-2, 9) * Complex(-9, 2) # => (0-85i)
-  #     Complex(9, 8)  * 4              # => (36+32i)
-  #     Complex(20, 9) * 9.8            # => (196.0+88.2i)
+  #     Complex.rect(2, 3)  * Complex.rect(2, 3)  # => (-5+12i)
+  #     Complex.rect(900)   * Complex.rect(1)     # => (900+0i)
+  #     Complex.rect(-2, 9) * Complex.rect(-9, 2) # => (0-85i)
+  #     Complex.rect(9, 8)  * 4                   # => (36+32i)
+  #     Complex.rect(20, 9) * 9.8                 # => (196.0+88.2i)
   #
   def *: (Numeric) -> Complex
 
@@ -129,8 +202,8 @@ class Complex < Numeric
   # -->
   # Returns `self` raised to power `numeric`:
   #
-  #     Complex('i') ** 2             # => (-1+0i)
-  #     Complex(-8) ** Rational(1, 3) # => (1.0000000000000002+1.7320508075688772i)
+  #     Complex.rect(0, 1) ** 2            # => (-1+0i)
+  #     Complex.rect(-8) ** Rational(1, 3) # => (1.0000000000000002+1.7320508075688772i)
   #
   def **: (Numeric) -> Complex
 
@@ -140,11 +213,11 @@ class Complex < Numeric
   # -->
   # Returns the sum of `self` and `numeric`:
   #
-  #     Complex(2, 3)  + Complex(2, 3)  # => (4+6i)
-  #     Complex(900)   + Complex(1)     # => (901+0i)
-  #     Complex(-2, 9) + Complex(-9, 2) # => (-11+11i)
-  #     Complex(9, 8)  + 4              # => (13+8i)
-  #     Complex(20, 9) + 9.8            # => (29.8+9i)
+  #     Complex.rect(2, 3)  + Complex.rect(2, 3)  # => (4+6i)
+  #     Complex.rect(900)   + Complex.rect(1)     # => (901+0i)
+  #     Complex.rect(-2, 9) + Complex.rect(-9, 2) # => (-11+11i)
+  #     Complex.rect(9, 8)  + 4                   # => (13+8i)
+  #     Complex.rect(20, 9) + 9.8                 # => (29.8+9i)
   #
   def +: (Numeric) -> Complex
 
@@ -156,11 +229,11 @@ class Complex < Numeric
   # -->
   # Returns the difference of `self` and `numeric`:
   #
-  #     Complex(2, 3)  - Complex(2, 3)  # => (0+0i)
-  #     Complex(900)   - Complex(1)     # => (899+0i)
-  #     Complex(-2, 9) - Complex(-9, 2) # => (7+7i)
-  #     Complex(9, 8)  - 4              # => (5+8i)
-  #     Complex(20, 9) - 9.8            # => (10.2+9i)
+  #     Complex.rect(2, 3)  - Complex.rect(2, 3)  # => (0+0i)
+  #     Complex.rect(900)   - Complex.rect(1)     # => (899+0i)
+  #     Complex.rect(-2, 9) - Complex.rect(-9, 2) # => (7+7i)
+  #     Complex.rect(9, 8)  - 4                   # => (5+8i)
+  #     Complex.rect(20, 9) - 9.8                 # => (10.2+9i)
   #
   def -: (Numeric) -> Complex
 
@@ -170,8 +243,8 @@ class Complex < Numeric
   # -->
   # Returns the negation of `self`, which is the negation of each of its parts:
   #
-  #     -Complex(1, 2)   # => (-1-2i)
-  #     -Complex(-1, -2) # => (1+2i)
+  #     -Complex.rect(1, 2)   # => (-1-2i)
+  #     -Complex.rect(-1, -2) # => (1+2i)
   #
   def -@: () -> Complex
 
@@ -181,11 +254,11 @@ class Complex < Numeric
   # -->
   # Returns the quotient of `self` and `numeric`:
   #
-  #     Complex(2, 3)  / Complex(2, 3)  # => ((1/1)+(0/1)*i)
-  #     Complex(900)   / Complex(1)     # => ((900/1)+(0/1)*i)
-  #     Complex(-2, 9) / Complex(-9, 2) # => ((36/85)-(77/85)*i)
-  #     Complex(9, 8)  / 4              # => ((9/4)+(2/1)*i)
-  #     Complex(20, 9) / 9.8            # => (2.0408163265306123+0.9183673469387754i)
+  #     Complex.rect(2, 3)  / Complex.rect(2, 3)  # => (1+0i)
+  #     Complex.rect(900)   / Complex.rect(1)     # => (900+0i)
+  #     Complex.rect(-2, 9) / Complex.rect(-9, 2) # => ((36/85)-(77/85)*i)
+  #     Complex.rect(9, 8)  / 4                   # => ((9/4)+2i)
+  #     Complex.rect(20, 9) / 9.8                 # => (2.0408163265306123+0.9183673469387754i)
   #
   def /: (Numeric) -> Complex
 
@@ -205,18 +278,16 @@ class Complex < Numeric
   #     *   `object.imag == 0`. # Always true if object is numeric but not
   #         complex.
   #
-  #
   # *   `nil` otherwise.
   #
-  #
   # Examples:
   #
-  #     Complex(2) <=> 3             # => -1
-  #     Complex(2) <=> 2             # => 0
-  #     Complex(2) <=> 1             # => 1
-  #     Complex(2, 1) <=> 1          # => nil # self.imag not zero.
-  #     Complex(1) <=> Complex(1, 1) # => nil # object.imag not zero.
-  #     Complex(1) <=> 'Foo'         # => nil # object.imag not defined.
+  #     Complex.rect(2) <=> 3                  # => -1
+  #     Complex.rect(2) <=> 2                  # => 0
+  #     Complex.rect(2) <=> 1                  # => 1
+  #     Complex.rect(2, 1) <=> 1               # => nil # self.imag not zero.
+  #     Complex.rect(1) <=> Complex.rect(1, 1) # => nil # object.imag not zero.
+  #     Complex.rect(1) <=> 'Foo'              # => nil # object.imag not defined.
   #
   def <=>: (untyped) -> Integer?
 
@@ -226,7 +297,7 @@ class Complex < Numeric
   # -->
   # Returns `true` if `self.real == object.real` and `self.imag == object.imag`:
   #
-  #     Complex(2, 3)  == Complex(2.0, 3.0)      # => true
+  #     Complex.rect(2, 3)  == Complex.rect(2.0, 3.0) # => true
   #
   def ==: (untyped) -> bool
 
@@ -348,9 +419,9 @@ class Complex < Numeric
   #   rdoc-file=complex.c
   #   - fdiv(numeric) -> new_complex
   # -->
-  # Returns `Complex(self.real/numeric, self.imag/numeric)`:
+  # Returns `Complex.rect(self.real/numeric, self.imag/numeric)`:
   #
-  #     Complex(11, 22).fdiv(3) # => (3.6666666666666665+7.333333333333333i)
+  #     Complex.rect(11, 22).fdiv(3) # => (3.6666666666666665+7.333333333333333i)
   #
   def fdiv: (Numeric) -> Complex
 
@@ -361,8 +432,8 @@ class Complex < Numeric
   # Returns `true` if both `self.real.finite?` and `self.imag.finite?` are true,
   # `false` otherwise:
   #
-  #     Complex(1, 1).finite?               # => true
-  #     Complex(Float::INFINITY, 0).finite? # => false
+  #     Complex.rect(1, 1).finite?               # => true
+  #     Complex.rect(Float::INFINITY, 0).finite? # => false
   #
   # Related: Numeric#finite?, Float#finite?.
   #
@@ -379,7 +450,7 @@ class Complex < Numeric
   # Two Complex objects created from the same values will have the same hash value
   # (and will compare using #eql?):
   #
-  #     Complex(1, 2).hash == Complex(1, 2).hash # => true
+  #     Complex.rect(1, 2).hash == Complex.rect(1, 2).hash # => true
   #
   def hash: () -> Integer
 
@@ -388,8 +459,8 @@ class Complex < Numeric
   # <!-- rdoc-file=complex.c -->
   # Returns the imaginary value for `self`:
   #
-  #     Complex(7).imaginary      #=> 0
-  #     Complex(9, -4).imaginary  #=> -4
+  #     Complex.rect(7).imag     # => 0
+  #     Complex.rect(9, -4).imag # => -4
   #
   # If `self` was created with [polar
   # coordinates](rdoc-ref:Complex@Polar+Coordinates), the returned value is
@@ -405,8 +476,8 @@ class Complex < Numeric
   # -->
   # Returns the imaginary value for `self`:
   #
-  #     Complex(7).imaginary      #=> 0
-  #     Complex(9, -4).imaginary  #=> -4
+  #     Complex.rect(7).imag     # => 0
+  #     Complex.rect(9, -4).imag # => -4
   #
   # If `self` was created with [polar
   # coordinates](rdoc-ref:Complex@Polar+Coordinates), the returned value is
@@ -423,8 +494,8 @@ class Complex < Numeric
   # Returns `1` if either `self.real.infinite?` or `self.imag.infinite?` is true,
   # `nil` otherwise:
   #
-  #     Complex(Float::INFINITY, 0).infinite? # => 1
-  #     Complex(1, 1).infinite?               # => nil
+  #     Complex.rect(Float::INFINITY, 0).infinite? # => 1
+  #     Complex.rect(1, 1).infinite?               # => nil
   #
   # Related: Numeric#infinite?, Float#infinite?.
   #
@@ -436,11 +507,11 @@ class Complex < Numeric
   # -->
   # Returns a string representation of `self`:
   #
-  #     Complex(2).inspect                      # => "(2+0i)"
-  #     Complex('-8/6').inspect                 # => "((-4/3)+0i)"
-  #     Complex('1/2i').inspect                 # => "(0+(1/2)*i)"
-  #     Complex(0, Float::INFINITY).inspect     # => "(0+Infinity*i)"
-  #     Complex(Float::NAN, Float::NAN).inspect # => "(NaN+NaN*i)"
+  #     Complex.rect(2).inspect                      # => "(2+0i)"
+  #     Complex.rect(-8, 6).inspect                  # => "(-8+6i)"
+  #     Complex.rect(0, Rational(1, 2)).inspect      # => "(0+(1/2)*i)"
+  #     Complex.rect(0, Float::INFINITY).inspect     # => "(0+Infinity*i)"
+  #     Complex.rect(Float::NAN, Float::NAN).inspect # => "(NaN+NaN*i)"
   #
   def inspect: () -> String
 
@@ -475,13 +546,13 @@ class Complex < Numeric
   # denominator](https://en.wikipedia.org/wiki/Lowest_common_denominator) of the
   # two:
   #
-  #     c = Complex(Rational(2, 3), Rational(3, 4)) # => ((2/3)+(3/4)*i)
-  #     c.numerator                                 # => (8+9i)
+  #     c = Complex.rect(Rational(2, 3), Rational(3, 4)) # => ((2/3)+(3/4)*i)
+  #     c.numerator                                      # => (8+9i)
   #
   # In this example, the lowest common denominator of the two parts is 12; the two
   # converted parts may be thought of as Rational(8, 12) and Rational(9, 12),
   # whose numerators, respectively, are 8 and 9; so the returned value of
-  # `c.numerator` is `Complex(8, 9)`.
+  # `c.numerator` is `Complex.rect(8, 9)`.
   #
   # Related: Complex#denominator.
   #
@@ -527,11 +598,11 @@ class Complex < Numeric
   # -->
   # Returns the quotient of `self` and `numeric`:
   #
-  #     Complex(2, 3)  / Complex(2, 3)  # => ((1/1)+(0/1)*i)
-  #     Complex(900)   / Complex(1)     # => ((900/1)+(0/1)*i)
-  #     Complex(-2, 9) / Complex(-9, 2) # => ((36/85)-(77/85)*i)
-  #     Complex(9, 8)  / 4              # => ((9/4)+(2/1)*i)
-  #     Complex(20, 9) / 9.8            # => (2.0408163265306123+0.9183673469387754i)
+  #     Complex.rect(2, 3)  / Complex.rect(2, 3)  # => (1+0i)
+  #     Complex.rect(900)   / Complex.rect(1)     # => (900+0i)
+  #     Complex.rect(-2, 9) / Complex.rect(-9, 2) # => ((36/85)-(77/85)*i)
+  #     Complex.rect(9, 8)  / 4                   # => ((9/4)+2i)
+  #     Complex.rect(20, 9) / 9.8                 # => (2.0408163265306123+0.9183673469387754i)
   #
   def quo: (Numeric) -> Complex
 
@@ -545,24 +616,24 @@ class Complex < Numeric
   # With no argument `epsilon` given, returns a Rational object whose value is
   # exactly equal to that of `self.real.rationalize`:
   #
-  #     Complex(1, 0).rationalize              # => (1/1)
-  #     Complex(1, Rational(0, 1)).rationalize # => (1/1)
-  #     Complex(3.14159, 0).rationalize        # => (314159/100000)
+  #     Complex.rect(1, 0).rationalize              # => (1/1)
+  #     Complex.rect(1, Rational(0, 1)).rationalize # => (1/1)
+  #     Complex.rect(3.14159, 0).rationalize        # => (314159/100000)
   #
   # With argument `epsilon` given, returns a Rational object whose value is
   # exactly or approximately equal to that of `self.real` to the given precision:
   #
-  #     Complex(3.14159, 0).rationalize(0.1)          # => (16/5)
-  #     Complex(3.14159, 0).rationalize(0.01)         # => (22/7)
-  #     Complex(3.14159, 0).rationalize(0.001)        # => (201/64)
-  #     Complex(3.14159, 0).rationalize(0.0001)       # => (333/106)
-  #     Complex(3.14159, 0).rationalize(0.00001)      # => (355/113)
-  #     Complex(3.14159, 0).rationalize(0.000001)     # => (7433/2366)
-  #     Complex(3.14159, 0).rationalize(0.0000001)    # => (9208/2931)
-  #     Complex(3.14159, 0).rationalize(0.00000001)   # => (47460/15107)
-  #     Complex(3.14159, 0).rationalize(0.000000001)  # => (76149/24239)
-  #     Complex(3.14159, 0).rationalize(0.0000000001) # => (314159/100000)
-  #     Complex(3.14159, 0).rationalize(0.0)          # => (3537115888337719/1125899906842624)
+  #     Complex.rect(3.14159, 0).rationalize(0.1)          # => (16/5)
+  #     Complex.rect(3.14159, 0).rationalize(0.01)         # => (22/7)
+  #     Complex.rect(3.14159, 0).rationalize(0.001)        # => (201/64)
+  #     Complex.rect(3.14159, 0).rationalize(0.0001)       # => (333/106)
+  #     Complex.rect(3.14159, 0).rationalize(0.00001)      # => (355/113)
+  #     Complex.rect(3.14159, 0).rationalize(0.000001)     # => (7433/2366)
+  #     Complex.rect(3.14159, 0).rationalize(0.0000001)    # => (9208/2931)
+  #     Complex.rect(3.14159, 0).rationalize(0.00000001)   # => (47460/15107)
+  #     Complex.rect(3.14159, 0).rationalize(0.000000001)  # => (76149/24239)
+  #     Complex.rect(3.14159, 0).rationalize(0.0000000001) # => (314159/100000)
+  #     Complex.rect(3.14159, 0).rationalize(0.0)          # => (3537115888337719/1125899906842624)
   #
   # Related: Complex#to_r.
   #
@@ -574,8 +645,8 @@ class Complex < Numeric
   # -->
   # Returns the real value for `self`:
   #
-  #     Complex(7).real      #=> 7
-  #     Complex(9, -4).real  #=> 9
+  #     Complex.rect(7).real     # => 7
+  #     Complex.rect(9, -4).real # => 9
   #
   # If `self` was created with [polar
   # coordinates](rdoc-ref:Complex@Polar+Coordinates), the returned value is
@@ -647,8 +718,8 @@ class Complex < Numeric
   # -->
   # Returns the value of `self.real` as a Float, if possible:
   #
-  #     Complex(1, 0).to_f              # => 1.0
-  #     Complex(1, Rational(0, 1)).to_f # => 1.0
+  #     Complex.rect(1, 0).to_f              # => 1.0
+  #     Complex.rect(1, Rational(0, 1)).to_f # => 1.0
   #
   # Raises RangeError if `self.imag` is not exactly zero (either `Integer(0)` or
   # `Rational(0, *n*)`).
@@ -661,8 +732,8 @@ class Complex < Numeric
   # -->
   # Returns the value of `self.real` as an Integer, if possible:
   #
-  #     Complex(1, 0).to_i              # => 1
-  #     Complex(1, Rational(0, 1)).to_i # => 1
+  #     Complex.rect(1, 0).to_i              # => 1
+  #     Complex.rect(1, Rational(0, 1)).to_i # => 1
   #
   # Raises RangeError if `self.imag` is not exactly zero (either `Integer(0)` or
   # `Rational(0, *n*)`).
@@ -677,11 +748,12 @@ class Complex < Numeric
   # -->
   # Returns the value of `self.real` as a Rational, if possible:
   #
-  #     Complex(1, 0).to_r              # => (1/1)
-  #     Complex(1, Rational(0, 1)).to_r # => (1/1)
+  #     Complex.rect(1, 0).to_r              # => (1/1)
+  #     Complex.rect(1, Rational(0, 1)).to_r # => (1/1)
+  #     Complex.rect(1, 0.0).to_r            # => (1/1)
   #
   # Raises RangeError if `self.imag` is not exactly zero (either `Integer(0)` or
-  # `Rational(0, *n*)`).
+  # `Rational(0, *n*)`) and `self.imag.to_r` is not exactly zero.
   #
   # Related: Complex#rationalize.
   #
@@ -693,11 +765,11 @@ class Complex < Numeric
   # -->
   # Returns a string representation of `self`:
   #
-  #     Complex(2).to_s                      # => "2+0i"
-  #     Complex('-8/6').to_s                 # => "-4/3+0i"
-  #     Complex('1/2i').to_s                 # => "0+1/2i"
-  #     Complex(0, Float::INFINITY).to_s     # => "0+Infinity*i"
-  #     Complex(Float::NAN, Float::NAN).to_s # => "NaN+NaN*i"
+  #     Complex.rect(2).to_s                      # => "2+0i"
+  #     Complex.rect(-8, 6).to_s                  # => "-8+6i"
+  #     Complex.rect(0, Rational(1, 2)).to_s      # => "0+1/2i"
+  #     Complex.rect(0, Float::INFINITY).to_s     # => "0+Infinity*i"
+  #     Complex.rect(Float::NAN, Float::NAN).to_s # => "NaN+NaN*i"
   #
   def to_s: () -> String
 
@@ -707,7 +779,7 @@ class Complex < Numeric
 end
 
 # <!-- rdoc-file=complex.c -->
-# Equivalent to `Complex(0, 1)`:
+# Equivalent to `Complex.rect(0, 1)`:
 #
 #     Complex::I # => (0+1i)
 #

data/core/data.rbs

@@ -83,7 +83,7 @@ class Data
   #     #=> #<data Measure amount=1, unit="km">
   #
   # Note that member-less Data is acceptable and might be a useful technique for
-  # defining several homogenous data classes, like
+  # defining several homogeneous data classes, like
   #
   #     class HTTPFetcher
   #       Response = Data.define(:body)
@@ -411,5 +411,5 @@ class Data
   #     out = origin.with(z: 1) # ArgumentError: unknown keyword: :z
   #     some_point = origin.with(1, 2) # ArgumentError: expected keyword arguments, got positional arguments
   #
-  def with: (**untyped) -> instance
+  def with: (**untyped) -> self
 end