rbs 0.12.1 → 0.15.0

data/stdlib/builtin/match_data.rbs

@@ -95,7 +95,7 @@ class MatchData
   #     f3    #=> "113"
   #     f4    #=> "8"
   #
-  def captures: () -> ::Array[String?] 
+  def captures: () -> ::Array[String?]
 
   # Returns the offset of the character immediately following the end of the *n*th
   # element of the match array in the string. *n* can be a string or symbol to

data/stdlib/builtin/method.rbs

@@ -4,7 +4,7 @@ class Method < Object
 
   # Invokes the *meth* with the specified arguments, returning the method’s
   # return value.
-  # 
+  #
   # ```ruby
   # m = 12.method("+")
   # m.call(3)    #=> 15
@@ -15,12 +15,12 @@ class Method < Object
   # Returns a proc that is the composition of this method and the given *g*
   # . The returned proc takes a variable number of arguments, calls *g* with
   # them then calls this method with the result.
-  # 
+  #
   # ```ruby
   # def f(x)
   #   x * x
   # end
-  # 
+  #
   # f = self.method(:f)
   # g = proc {|x| x + x }
   # p (f << g).call(2) #=> 16
@@ -30,10 +30,10 @@ class Method < Object
   # Invokes the method with `obj` as the parameter like
   # [call](Method.downloaded.ruby_doc#method-i-call). This allows a method
   # object to be the target of a `when` clause in a case statement.
-  # 
+  #
   # ```ruby
   # require 'prime'
-  # 
+  #
   # case 1373
   # when Prime.method(:prime?)
   #   # ...
@@ -44,12 +44,12 @@ class Method < Object
   # Returns a proc that is the composition of this method and the given *g*
   # . The returned proc takes a variable number of arguments, calls *g* with
   # them then calls this method with the result.
-  # 
+  #
   # ```ruby
   # def f(x)
   #   x * x
   # end
-  # 
+  #
   # f = self.method(:f)
   # g = proc {|x| x + x }
   # p (f >> g).call(2) #=> 8
@@ -58,7 +58,7 @@ class Method < Object
 
   # Invokes the *meth* with the specified arguments, returning the method’s
   # return value.
-  # 
+  #
   # ```ruby
   # m = 12.method("+")
   # m.call(3)    #=> 15
@@ -74,7 +74,7 @@ class Method < Object
   # argument being mandatory if any keyword argument is mandatory. For
   # methods written in C, returns -1 if the call takes a variable number of
   # arguments.
-  # 
+  #
   #     class C
   #       def one;    end
   #       def two(a); end
@@ -98,7 +98,7 @@ class Method < Object
   #     c.method(:eight).arity   #=> 1
   #     c.method(:nine).arity    #=> 1
   #     c.method(:ten).arity     #=> -2
-  # 
+  #
   #     "cat".method(:size).arity      #=> 0
   #     "cat".method(:replace).arity   #=> 1
   #     "cat".method(:squeeze).arity   #=> -1
@@ -106,14 +106,14 @@ class Method < Object
   def arity: () -> Integer
 
   # Returns a clone of this method.
-  # 
+  #
   # ```ruby
   # class A
   #   def foo
   #     return "bar"
   #   end
   # end
-  # 
+  #
   # m = A.new.method(:foo)
   # m.call # => "bar"
   # n = m.clone.call # => "bar"
@@ -126,7 +126,7 @@ class Method < Object
   def name: () -> Symbol
 
   # Returns the original name of the method.
-  # 
+  #
   # ```ruby
   # class C
   #   def foo; end
@@ -137,24 +137,24 @@ class Method < Object
   def original_name: () -> Symbol
 
   # Returns the class or module that defines the method. See also receiver.
-  # 
+  #
   # ```ruby
   # (1..3).method(:map).owner #=> Enumerable
   # ```
   def owner: () -> (Class | Module)
 
   # Returns the parameter information of this method.
-  # 
+  #
   # ```ruby
   # def foo(bar); end
   # method(:foo).parameters #=> [[:req, :bar]]
-  # 
+  #
   # def foo(bar, baz, bat, &blk); end
   # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:req, :bat], [:block, :blk]]
-  # 
+  #
   # def foo(bar, *args); end
   # method(:foo).parameters #=> [[:req, :bar], [:rest, :args]]
-  # 
+  #
   # def foo(bar, baz, *args, &blk); end
   # method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:rest, :args], [:block, :blk]]
   # ```
@@ -164,7 +164,7 @@ class Method < Object
   ]
 
   # Returns the bound receiver of the method object.
-  # 
+  #
   # ```ruby
   # (1..3).method(:map).receiver # => 1..3
   # ```

data/stdlib/builtin/module.rbs

@@ -237,7 +237,7 @@ class Module < Object
   #     B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
   #     B.autoload?(:CONST, false)   #=> nil, not found in B itself
   #
-  def autoload?: (Symbol name, ?bool inherit) -> String?
+  def autoload?: (Symbol name, ?boolish inherit) -> String?
 
   # Evaluates the string or block in the context of *mod*, except that when a
   # block is given, constant/class variable lookup is not affected. This can be
@@ -329,7 +329,7 @@ class Module < Object
   #     Two.class_variables          #=> [:@@var2, :@@var1]
   #     Two.class_variables(false)   #=> [:@@var2]
   #
-  def class_variables: (?bool inherit) -> ::Array[Symbol]
+  def class_variables: (?boolish inherit) -> ::Array[Symbol]
 
   # Says whether *mod* or its ancestors have a constant with the given name:
   #
@@ -364,7 +364,7 @@ class Module < Object
   #
   #     Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar
   #
-  def const_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def const_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # Checks for a constant with the given name in *mod*. If `inherit` is set, the
   # lookup will also search the ancestors (and `Object` if *mod* is a `Module`).
@@ -398,7 +398,7 @@ class Module < Object
   #
   #     Object.const_get 'foobar' #=> NameError: wrong constant name foobar
   #
-  def const_get: (Symbol | String arg0, ?bool inherit) -> untyped
+  def const_get: (Symbol | String name, ?boolish inherit) -> untyped
 
   # Invoked when a reference is made to an undefined constant in *mod*. It is
   # passed a symbol for the undefined constant, and returns a value to be used for
@@ -455,7 +455,7 @@ class Module < Object
   #
   # Also see Module#const_defined?.
   #
-  def constants: (?bool inherit) -> ::Array[Symbol]
+  def constants: (?boolish inherit) -> ::Array[Symbol]
 
   # Defines an instance method in the receiver. The *method* parameter can be a
   # `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, it
@@ -662,7 +662,7 @@ class Module < Object
   #     C.instance_methods(false)                   #=> [:method3]
   #     C.instance_methods.include?(:method2)       #=> true
   #
-  def instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Invoked as a callback whenever an instance method is added to the receiver.
   #
@@ -709,7 +709,7 @@ class Module < Object
   #     C.method_defined? "method4"             #=> false
   #     C.method_defined? "private_method2"     #=> false
   #
-  def method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # Invoked as a callback whenever an instance method is removed from the
   # receiver.
@@ -881,7 +881,7 @@ class Module < Object
   #     Mod.instance_methods           #=> [:method2]
   #     Mod.private_instance_methods   #=> [:method1]
   #
-  def private_instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def private_instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Returns `true` if the named private method is defined by *mod*.  If *inherit*
   # is set, the lookup will also search *mod*'s ancestors. String arguments are
@@ -906,7 +906,7 @@ class Module < Object
   #     C.private_method_defined? "method2", false   #=> false
   #     C.method_defined? "method2"                  #=> false
   #
-  def private_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def private_method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # With no arguments, sets the default visibility for subsequently defined
   # methods to protected. With arguments, sets the named methods to have protected
@@ -926,7 +926,7 @@ class Module < Object
   # Returns a list of the protected instance methods defined in *mod*. If the
   # optional parameter is `false`, the methods of any ancestors are not included.
   #
-  def protected_instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def protected_instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Returns `true` if the named protected method is defined *mod*.  If *inherit*
   # is set, the lookup will also search *mod*'s ancestors. String arguments are
@@ -951,7 +951,7 @@ class Module < Object
   #     C.protected_method_defined? "method2", false  #=> false
   #     C.method_defined? "method2"                   #=> true
   #
-  def protected_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def protected_method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # With no arguments, sets the default visibility for subsequently defined
   # methods to public. With arguments, sets the named methods to have public
@@ -976,7 +976,7 @@ class Module < Object
   # Returns a list of the public instance methods defined in *mod*. If the
   # optional parameter is `false`, the methods of any ancestors are not included.
   #
-  def public_instance_methods: (?bool include_super) -> ::Array[Symbol]
+  def public_instance_methods: (?boolish include_super) -> ::Array[Symbol]
 
   # Returns `true` if the named public method is defined by *mod*.  If *inherit*
   # is set, the lookup will also search *mod*'s ancestors. String arguments are
@@ -1001,7 +1001,7 @@ class Module < Object
   #     C.public_method_defined? "method2"         #=> false
   #     C.method_defined? "method2"                #=> true
   #
-  def public_method_defined?: (Symbol | String arg0, ?bool inherit) -> bool
+  def public_method_defined?: (Symbol | String name, ?boolish inherit) -> bool
 
   # Refine *mod* in the receiver.
   #

data/stdlib/builtin/nil_class.rbs

@@ -1,81 +1,81 @@
 # The class of the singleton object `nil`.
-# 
+#
 class NilClass
   public
 
   # And---Returns `false`. *obj* is always evaluated as it is the argument to a
   # method call---there is no short-circuit evaluation in this case.
-  # 
+  #
   def &: (untyped obj) -> bool
 
   # Case Equality -- For class Object, effectively the same as calling `#==`, but
   # typically overridden by descendants to provide meaningful semantics in `case`
   # statements.
-  # 
+  #
   def ===: (nil) -> true
          | (untyped obj) -> bool
 
   # Dummy pattern matching -- always returns nil.
-  # 
+  #
   def =~: (untyped obj) -> nil
 
   # Exclusive Or---If *obj* is `nil` or `false`, returns `false`; otherwise,
   # returns `true`.
-  # 
+  #
   def ^: (nil) -> false
        | (false) -> false
        | (untyped obj) -> bool
 
   # Always returns the string "nil".
-  # 
+  #
   def inspect: () -> "nil"
 
   # Only the object *nil* responds `true` to `nil?`.
-  # 
+  #
   def nil?: () -> bool
 
   # Returns zero as a rational.  The optional argument `eps` is always ignored.
-  # 
+  #
   def rationalize: (?untyped eps) -> Rational
 
   # Always returns an empty array.
-  # 
+  #
   #     nil.to_a   #=> []
-  # 
+  #
   def to_a: () -> [ ]
 
   # Returns zero as a complex.
-  # 
+  #
   def to_c: () -> Complex
 
   # Always returns zero.
-  # 
+  #
   #     nil.to_f   #=> 0.0
-  # 
+  #
   def to_f: () -> Float
 
   # Always returns an empty hash.
-  # 
+  #
   #     nil.to_h   #=> {}
-  # 
+  #
   def to_h: () -> ::Hash[untyped, untyped]
 
   # Always returns zero.
-  # 
+  #
   #     nil.to_i   #=> 0
-  # 
+  #
   def to_i: () -> 0
 
   # Returns zero as a rational.
-  # 
+  #
   def to_r: () -> Rational
 
   # Always returns the empty string.
-  # 
+  #
   def to_s: () -> ""
 
   # Or---Returns `false` if *obj* is `nil` or `false`; `true` otherwise.
-  # 
+  #
   def |: (nil) -> false
        | (false) -> false
        | (untyped obj) -> bool

data/stdlib/builtin/numeric.rbs

@@ -1,176 +1,176 @@
 # Numeric is the class from which all higher-level numeric classes should
 # inherit.
-# 
+#
 # Numeric allows instantiation of heap-allocated objects. Other core numeric
 # classes such as Integer are implemented as immediates, which means that each
 # Integer is a single immutable object which is always passed by value.
-# 
+#
 #     a = 1
 #     1.object_id == a.object_id   #=> true
-# 
+#
 # There can only ever be one instance of the integer `1`, for example. Ruby
 # ensures this by preventing instantiation. If duplication is attempted, the
 # same instance is returned.
-# 
+#
 #     Integer.new(1)                   #=> NoMethodError: undefined method `new' for Integer:Class
 #     1.dup                            #=> 1
 #     1.object_id == 1.dup.object_id   #=> true
-# 
+#
 # For this reason, Numeric should be used when defining other numeric classes.
-# 
+#
 # Classes which inherit from Numeric must implement `coerce`, which returns a
 # two-member Array containing an object that has been coerced into an instance
 # of the new class and `self` (see #coerce).
-# 
+#
 # Inheriting classes should also implement arithmetic operator methods (`+`,
 # `-`, `*` and `/`) and the `<=>` operator (see Comparable). These methods may
 # rely on `coerce` to ensure interoperability with instances of other numeric
 # classes.
-# 
+#
 #     class Tally < Numeric
 #       def initialize(string)
 #         @string = string
 #       end
-# 
+#
 #       def to_s
 #         @string
 #       end
-# 
+#
 #       def to_i
 #         @string.size
 #       end
-# 
+#
 #       def coerce(other)
 #         [self.class.new('|' * other.to_i), self]
 #       end
-# 
+#
 #       def <=>(other)
 #         to_i <=> other.to_i
 #       end
-# 
+#
 #       def +(other)
 #         self.class.new('|' * (to_i + other.to_i))
 #       end
-# 
+#
 #       def -(other)
 #         self.class.new('|' * (to_i - other.to_i))
 #       end
-# 
+#
 #       def *(other)
 #         self.class.new('|' * (to_i * other.to_i))
 #       end
-# 
+#
 #       def /(other)
 #         self.class.new('|' * (to_i / other.to_i))
 #       end
 #     end
-# 
+#
 #     tally = Tally.new('||')
 #     puts tally * 2            #=> "||||"
 #     puts tally > 1            #=> true
-# 
+#
 class Numeric
   include Comparable
 
   public
 
   # `x.modulo(y)` means `x-y*(x/y).floor`.
-  # 
+  #
   # Equivalent to `num.divmod(numeric)[1]`.
-  # 
+  #
   # See Numeric#divmod.
-  # 
+  #
   def %: (Numeric) -> Numeric
 
   # Unary Plus---Returns the receiver.
-  # 
+  #
   def +@: () -> Numeric
 
   # Unary Minus---Returns the receiver, negated.
-  # 
+  #
   def -@: () -> Numeric
 
   # Returns zero if `number` equals `other`, otherwise returns `nil`.
-  # 
+  #
   def <=>: (Numeric other) -> Integer
 
   # Returns the absolute value of `num`.
-  # 
+  #
   #     12.abs         #=> 12
   #     (-34.56).abs   #=> 34.56
   #     -34.56.abs     #=> 34.56
-  # 
+  #
   # Numeric#magnitude is an alias for Numeric#abs.
-  # 
+  #
   def abs: () -> Numeric
 
   # Returns square of self.
-  # 
+  #
   def abs2: () -> Numeric
 
   # Returns 0 if the value is positive, pi otherwise.
-  # 
+  #
   def angle: () -> Numeric
 
   # Returns 0 if the value is positive, pi otherwise.
-  # 
+  #
   alias arg angle
 
   # Returns the smallest number greater than or equal to `num` with a precision of
   # `ndigits` decimal digits (default: 0).
-  # 
+  #
   # Numeric implements this by converting its value to a Float and invoking
   # Float#ceil.
-  # 
+  #
   def ceil: () -> Integer
           | (Integer digits) -> (Integer | Numeric)
 
   # If `numeric` is the same type as `num`, returns an array `[numeric, num]`.
   # Otherwise, returns an array with both `numeric` and `num` represented as Float
   # objects.
-  # 
+  #
   # This coercion mechanism is used by Ruby to handle mixed-type numeric
   # operations: it is intended to find a compatible common type between the two
   # operands of the operator.
-  # 
+  #
   #     1.coerce(2.5)   #=> [2.5, 1.0]
   #     1.2.coerce(3)   #=> [3.0, 1.2]
   #     1.coerce(2)     #=> [2, 1]
-  # 
+  #
   def coerce: (Numeric) -> [ Numeric, Numeric ]
 
   # Returns self.
-  # 
+  #
   def conj: () -> Numeric
 
   # Returns self.
-  # 
+  #
   def conjugate: () -> Numeric
 
   # Returns the denominator (always positive).
-  # 
+  #
   def denominator: () -> Integer
 
   # Uses `/` to perform division, then converts the result to an integer. Numeric
   # does not define the `/` operator; this is left to subclasses.
-  # 
+  #
   # Equivalent to `num.divmod(numeric)[0]`.
-  # 
+  #
   # See Numeric#divmod.
-  # 
+  #
   def div: (Numeric) -> Integer
 
   # Returns an array containing the quotient and modulus obtained by dividing
   # `num` by `numeric`.
-  # 
+  #
   # If `q, r = x.divmod(y)`, then
-  # 
+  #
   #     q = floor(x/y)
   #     x = q*y + r
-  # 
+  #
   # The quotient is rounded toward negative infinity, as shown in the following
   # table:
-  # 
+  #
   #      a    |  b  |  a.divmod(b)  |   a/b   | a.modulo(b) | a.remainder(b)
   #     ------+-----+---------------+---------+-------------+---------------
   #      13   |  4  |   3,    1     |   3     |    1        |     1
@@ -188,222 +188,222 @@ class Numeric
   #     -11.5 |  4  |  -3,    0.5   |  -2.875 |    0.5      |    -3.5
   #     ------+-----+---------------+---------+-------------+---------------
   #     -11.5 | -4  |   2,   -3.5   |   2.875 |   -3.5      |    -3.5
-  # 
+  #
   # Examples
-  # 
+  #
   #     11.divmod(3)        #=> [3, 2]
   #     11.divmod(-3)       #=> [-4, -1]
   #     11.divmod(3.5)      #=> [3, 0.5]
   #     (-11).divmod(3.5)   #=> [-4, 3.0]
   #     11.5.divmod(3.5)    #=> [3, 1.0]
-  # 
+  #
   def divmod: (Numeric) -> [ Numeric, Numeric ]
 
   # Returns `true` if `num` and `numeric` are the same type and have equal values.
   #  Contrast this with Numeric#==, which performs type conversions.
-  # 
+  #
   #     1 == 1.0        #=> true
   #     1.eql?(1.0)     #=> false
   #     1.0.eql?(1.0)   #=> true
-  # 
+  #
   def eql?: (untyped) -> bool
 
   # Returns float division.
-  # 
+  #
   def fdiv: (Numeric) -> Numeric
 
   # Returns `true` if `num` is a finite number, otherwise returns `false`.
-  # 
+  #
   def finite?: () -> bool
 
   # Returns the largest number less than or equal to `num` with a precision of
   # `ndigits` decimal digits (default: 0).
-  # 
+  #
   # Numeric implements this by converting its value to a Float and invoking
   # Float#floor.
-  # 
+  #
   def floor: () -> Integer
            | (Integer digits) -> Numeric
 
   # Returns the corresponding imaginary number. Not available for complex numbers.
-  # 
+  #
   #     -42.i  #=> (0-42i)
   #     2.0.i  #=> (0+2.0i)
-  # 
+  #
   def i: () -> Complex
 
   # Returns zero.
-  # 
+  #
   def imag: () -> Numeric
 
   # Returns zero.
-  # 
+  #
   def imaginary: () -> Numeric
 
   # Returns `nil`, -1, or 1 depending on whether the value is finite, `-Infinity`,
   # or `+Infinity`.
-  # 
+  #
   def infinite?: () -> Integer?
 
   # Returns `true` if `num` is an Integer.
-  # 
+  #
   #     1.0.integer?   #=> false
   #     1.integer?     #=> true
-  # 
+  #
   def integer?: () -> bool
 
   # Returns the absolute value of `num`.
-  # 
+  #
   #     12.abs         #=> 12
   #     (-34.56).abs   #=> 34.56
   #     -34.56.abs     #=> 34.56
-  # 
+  #
   # Numeric#magnitude is an alias for Numeric#abs.
-  # 
+  #
   alias magnitude abs
 
   # `x.modulo(y)` means `x-y*(x/y).floor`.
-  # 
+  #
   # Equivalent to `num.divmod(numeric)[1]`.
-  # 
+  #
   # See Numeric#divmod.
-  # 
+  #
   def modulo: (Numeric) -> Numeric
 
   # Returns `true` if `num` is less than 0.
-  # 
+  #
   def negative?: () -> bool
 
   # Returns `self` if `num` is not zero, `nil` otherwise.
-  # 
+  #
   # This behavior is useful when chaining comparisons:
-  # 
+  #
   #     a = %w( z Bb bB bb BB a aA Aa AA A )
   #     b = a.sort {|a,b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
   #     b   #=> ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]
-  # 
+  #
   def nonzero?: () -> self?
 
   # Returns the numerator.
-  # 
+  #
   def numerator: () -> Numeric
 
   # Returns 0 if the value is positive, pi otherwise.
-  # 
+  #
   alias phase angle
 
   # Returns an array; [num.abs, num.arg].
-  # 
+  #
   def polar: () -> [ Numeric, Numeric ]
 
   # Returns `true` if `num` is greater than 0.
-  # 
+  #
   def positive?: () -> bool
 
   # Returns the most exact division (rational for integers, float for floats).
-  # 
+  #
   def quo: (Numeric) -> Numeric
 
   # Returns self.
-  # 
+  #
   def real: () -> Numeric
 
   # Returns `true` if `num` is a real number (i.e. not Complex).
-  # 
+  #
   def real?: () -> bool
 
   # Returns an array; [num, 0].
-  # 
+  #
   def rect: () -> [ Numeric, Numeric ]
 
   # Returns an array; [num, 0].
-  # 
+  #
   alias rectangular rect
 
   # `x.remainder(y)` means `x-y*(x/y).truncate`.
-  # 
+  #
   # See Numeric#divmod.
-  # 
+  #
   def remainder: (Numeric) -> Numeric
 
   # Returns `num` rounded to the nearest value with a precision of `ndigits`
   # decimal digits (default: 0).
-  # 
+  #
   # Numeric implements this by converting its value to a Float and invoking
   # Float#round.
-  # 
+  #
   def round: () -> Integer
            | (Integer digits) -> Numeric
 
   # Invokes the given block with the sequence of numbers starting at `num`,
   # incremented by `step` (defaulted to `1`) on each call.
-  # 
+  #
   # The loop finishes when the value to be passed to the block is greater than
   # `limit` (if `step` is positive) or less than `limit` (if `step` is negative),
   # where `limit` is defaulted to infinity.
-  # 
+  #
   # In the recommended keyword argument style, either or both of `step` and
   # `limit` (default infinity) can be omitted.  In the fixed position argument
   # style, zero as a step (i.e. `num.step(limit, 0)`) is not allowed for
   # historical compatibility reasons.
-  # 
+  #
   # If all the arguments are integers, the loop operates using an integer counter.
-  # 
+  #
   # If any of the arguments are floating point numbers, all are converted to
   # floats, and the loop is executed *floor(n + n*Float::EPSILON) + 1* times,
   # where *n = (limit - num)/step*.
-  # 
+  #
   # Otherwise, the loop starts at `num`, uses either the less-than (`<`) or
   # greater-than (`>`) operator to compare the counter against `limit`, and
   # increments itself using the `+` operator.
-  # 
+  #
   # If no block is given, an Enumerator is returned instead. Especially, the
   # enumerator is an Enumerator::ArithmeticSequence if both `limit` and `step` are
   # kind of Numeric or `nil`.
-  # 
+  #
   # For example:
-  # 
+  #
   #     p 1.step.take(4)
   #     p 10.step(by: -1).take(4)
   #     3.step(to: 5) {|i| print i, " " }
   #     1.step(10, 2) {|i| print i, " " }
   #     Math::E.step(to: Math::PI, by: 0.2) {|f| print f, " " }
-  # 
+  #
   # Will produce:
-  # 
+  #
   #     [1, 2, 3, 4]
   #     [10, 9, 8, 7]
   #     3 4 5
   #     1 3 5 7 9
   #     2.718281828459045 2.9182818284590453 3.118281828459045
-  # 
+  #
   def step: (?Numeric limit, ?Numeric step) { (Numeric) -> void } -> self
           | (?Numeric limit, ?Numeric step) -> Enumerator[Numeric, self]
           | (?by: Numeric, ?to: Numeric) { (Numeric) -> void } -> self
           | (?by: Numeric, ?to: Numeric) -> Enumerator[Numeric, self]
 
   # Returns the value as a complex.
-  # 
+  #
   def to_c: () -> Complex
 
   # Invokes the child class's `to_i` method to convert `num` to an integer.
-  # 
+  #
   #     1.0.class          #=> Float
   #     1.0.to_int.class   #=> Integer
   #     1.0.to_i.class     #=> Integer
-  # 
+  #
   def to_int: () -> Integer
 
   # Returns `num` truncated (toward zero) to a precision of `ndigits` decimal
   # digits (default: 0).
-  # 
+  #
   # Numeric implements this by converting its value to a Float and invoking
   # Float#truncate.
-  # 
+  #
   def truncate: () -> Integer
               | (Integer ndigits) -> (Integer | Numeric)
 
   # Returns `true` if `num` has a zero value.
-  # 
+  #
   def zero?: () -> bool
 end