steep 0.14.0 → 0.16.3

data/vendor/ruby-signature/stdlib/builtin/numeric.rbs

@@ -1,409 +0,0 @@
-# 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
-  #     ------+-----+---------------+---------+-------------+---------------
-  #      13   | -4  |  -4,   -3     |  -4     |   -3        |     1
-  #     ------+-----+---------------+---------+-------------+---------------
-  #     -13   |  4  |  -4,    3     |  -4     |    3        |    -1
-  #     ------+-----+---------------+---------+-------------+---------------
-  #     -13   | -4  |   3,   -1     |   3     |   -1        |    -1
-  #     ------+-----+---------------+---------+-------------+---------------
-  #      11.5 |  4  |   2,    3.5   |   2.875 |    3.5      |     3.5
-  #     ------+-----+---------------+---------+-------------+---------------
-  #      11.5 | -4  |  -3,   -0.5   |  -2.875 |   -0.5      |     3.5
-  #     ------+-----+---------------+---------+-------------+---------------
-  #     -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

data/vendor/ruby-signature/stdlib/builtin/object.rbs

@@ -1,824 +0,0 @@
-# Object is the default root of all Ruby objects.  Object inherits from
-# BasicObject which allows creating alternate object hierarchies.  Methods on
-# Object are available to all classes unless explicitly overridden.
-# 
-# Object mixes in the Kernel module, making the built-in kernel functions
-# globally accessible.  Although the instance methods of Object are defined by
-# the Kernel module, we have chosen to document them here for clarity.
-# 
-# When referencing constants in classes inheriting from Object you do not need
-# to use the full namespace.  For example, referencing `File` inside `YourClass`
-# will find the top-level File class.
-# 
-# In the descriptions of Object's methods, the parameter *symbol* refers to a
-# symbol, which is either a quoted string or a Symbol (such as `:name`).
-# 
-class Object < BasicObject
-  include Kernel
-
-  # Returns true if two objects do not match (using the *=~* method), otherwise
-  # false.
-  # 
-  def !~: (untyped) -> bool
-
-  # Returns 0 if `obj` and `other` are the same object or `obj == other`,
-  # otherwise nil.
-  # 
-  # The `<=>` is used by various methods to compare objects, for example
-  # Enumerable#sort, Enumerable#max etc.
-  # 
-  # Your implementation of `<=>` should return one of the following values: -1, 0,
-  # 1 or nil. -1 means self is smaller than other. 0 means self is equal to other.
-  # 1 means self is bigger than other. Nil means the two values could not be
-  # compared.
-  # 
-  # When you define `<=>`, you can include Comparable to gain the methods `<=`,
-  # `<`, `==`, `>=`, `>` and `between?`.
-  # 
-  def <=>: (untyped) -> Integer?
-
-  # Case Equality -- For class Object, effectively the same as calling `#==`, but
-  # typically overridden by descendants to provide meaningful semantics in `case`
-  # statements.
-  # 
-  def ===: (untyped) -> bool
-
-  # This method is deprecated.
-  # 
-  # This is not only unuseful but also troublesome because it may hide a type
-  # error.
-  # 
-  def =~: (untyped) -> bool
-
-  # Returns the class of *obj*. This method must always be called with an explicit
-  # receiver, as `class` is also a reserved word in Ruby.
-  # 
-  #     1.class      #=> Integer
-  #     self.class   #=> Object
-  # 
-  def `class`: () -> untyped
-
-  # Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
-  # but not the objects they reference. `clone` copies the frozen (unless :freeze
-  # keyword argument is given with a false value) and tainted state of *obj*. See
-  # also the discussion under `Object#dup`.
-  # 
-  #     class Klass
-  #        attr_accessor :str
-  #     end
-  #     s1 = Klass.new      #=> #<Klass:0x401b3a38>
-  #     s1.str = "Hello"    #=> "Hello"
-  #     s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
-  #     s2.str[1,4] = "i"   #=> "i"
-  #     s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
-  #     s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"
-  # 
-  # This method may have class-specific behavior.  If so, that behavior will be
-  # documented under the #`initialize_copy` method of the class.
-  # 
-  def clone: (?freeze: bool) -> self
-
-  # Defines a singleton method in the receiver. The *method* parameter can be a
-  # `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, it
-  # is used as the method body.
-  # 
-  #     class A
-  #       class << self
-  #         def class_name
-  #           to_s
-  #         end
-  #       end
-  #     end
-  #     A.define_singleton_method(:who_am_i) do
-  #       "I am: #{class_name}"
-  #     end
-  #     A.who_am_i   # ==> "I am: A"
-  # 
-  #     guy = "Bob"
-  #     guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
-  #     guy.hello    #=>  "Bob: Hello there!"
-  # 
-  def define_singleton_method: (Symbol, Method | UnboundMethod) -> Symbol
-                             | (Symbol) { (*untyped) -> untyped } -> Symbol
-
-  # Prints *obj* on the given port (default `$>`). Equivalent to:
-  # 
-  #     def display(port=$>)
-  #       port.write self
-  #       nil
-  #     end
-  # 
-  # For example:
-  # 
-  #     1.display
-  #     "cat".display
-  #     [ 4, 5, 6 ].display
-  #     puts
-  # 
-  # *produces:*
-  # 
-  #     1cat[4, 5, 6]
-  # 
-  def display: (?_Writeable port) -> void
-
-  # Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
-  # but not the objects they reference. `dup` copies the tainted state of *obj*.
-  # 
-  # This method may have class-specific behavior.  If so, that behavior will be
-  # documented under the #`initialize_copy` method of the class.
-  # 
-  # ### on dup vs clone
-  # 
-  # In general, `clone` and `dup` may have different semantics in descendant
-  # classes. While `clone` is used to duplicate an object, including its internal
-  # state, `dup` typically uses the class of the descendant object to create the
-  # new instance.
-  # 
-  # When using #dup, any modules that the object has been extended with will not
-  # be copied.
-  # 
-  #     class Klass
-  #       attr_accessor :str
-  #     end
-  # 
-  #     module Foo
-  #       def foo; 'foo'; end
-  #     end
-  # 
-  #     s1 = Klass.new #=> #<Klass:0x401b3a38>
-  #     s1.extend(Foo) #=> #<Klass:0x401b3a38>
-  #     s1.foo #=> "foo"
-  # 
-  #     s2 = s1.clone #=> #<Klass:0x401b3a38>
-  #     s2.foo #=> "foo"
-  # 
-  #     s3 = s1.dup #=> #<Klass:0x401b3a38>
-  #     s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401b3a38>
-  # 
-  def dup: () -> self
-
-  # Creates a new Enumerator which will enumerate by calling `method` on `obj`,
-  # passing `args` if any.
-  # 
-  # If a block is given, it will be used to calculate the size of the enumerator
-  # without the need to iterate it (see Enumerator#size).
-  # 
-  # ### Examples
-  # 
-  #     str = "xyz"
-  # 
-  #     enum = str.enum_for(:each_byte)
-  #     enum.each { |b| puts b }
-  #     # => 120
-  #     # => 121
-  #     # => 122
-  # 
-  #     # protect an array from being modified by some_method
-  #     a = [1, 2, 3]
-  #     some_method(a.to_enum)
-  # 
-  # It is typical to call to_enum when defining methods for a generic Enumerable,
-  # in case no block is passed.
-  # 
-  # Here is such an example, with parameter passing and a sizing block:
-  # 
-  #     module Enumerable
-  #       # a generic method to repeat the values of any enumerable
-  #       def repeat(n)
-  #         raise ArgumentError, "#{n} is negative!" if n < 0
-  #         unless block_given?
-  #           return to_enum(__method__, n) do # __method__ is :repeat here
-  #             sz = size     # Call size and multiply by n...
-  #             sz * n if sz  # but return nil if size itself is nil
-  #           end
-  #         end
-  #         each do |*val|
-  #           n.times { yield *val }
-  #         end
-  #       end
-  #     end
-  # 
-  #     %i[hello world].repeat(2) { |w| puts w }
-  #       # => Prints 'hello', 'hello', 'world', 'world'
-  #     enum = (1..14).repeat(3)
-  #       # => returns an Enumerator when called without a block
-  #     enum.first(4) # => [1, 1, 1, 2]
-  #     enum.size # => 42
-  # 
-  def enum_for: (Symbol method, *untyped args) ?{ (*untyped args) -> Integer } -> Enumerator[untyped, untyped]
-              | (*untyped args) ?{ (*untyped args) -> Integer } -> Enumerator[untyped, untyped]
-
-  # Creates a new Enumerator which will enumerate by calling `method` on `obj`,
-  # passing `args` if any.
-  # 
-  # If a block is given, it will be used to calculate the size of the enumerator
-  # without the need to iterate it (see Enumerator#size).
-  # 
-  # ### Examples
-  # 
-  #     str = "xyz"
-  # 
-  #     enum = str.enum_for(:each_byte)
-  #     enum.each { |b| puts b }
-  #     # => 120
-  #     # => 121
-  #     # => 122
-  # 
-  #     # protect an array from being modified by some_method
-  #     a = [1, 2, 3]
-  #     some_method(a.to_enum)
-  # 
-  # It is typical to call to_enum when defining methods for a generic Enumerable,
-  # in case no block is passed.
-  # 
-  # Here is such an example, with parameter passing and a sizing block:
-  # 
-  #     module Enumerable
-  #       # a generic method to repeat the values of any enumerable
-  #       def repeat(n)
-  #         raise ArgumentError, "#{n} is negative!" if n < 0
-  #         unless block_given?
-  #           return to_enum(__method__, n) do # __method__ is :repeat here
-  #             sz = size     # Call size and multiply by n...
-  #             sz * n if sz  # but return nil if size itself is nil
-  #           end
-  #         end
-  #         each do |*val|
-  #           n.times { yield *val }
-  #         end
-  #       end
-  #     end
-  # 
-  #     %i[hello world].repeat(2) { |w| puts w }
-  #       # => Prints 'hello', 'hello', 'world', 'world'
-  #     enum = (1..14).repeat(3)
-  #       # => returns an Enumerator when called without a block
-  #     enum.first(4) # => [1, 1, 1, 2]
-  #     enum.size # => 42
-  # 
-  alias to_enum enum_for
-
-  # Equality --- At the `Object` level, `==` returns `true` only if `obj` and
-  # `other` are the same object. Typically, this method is overridden in
-  # descendant classes to provide class-specific meaning.
-  # 
-  # Unlike `==`, the `equal?` method should never be overridden by subclasses as
-  # it is used to determine object identity (that is, `a.equal?(b)` if and only if
-  # `a` is the same object as `b`):
-  # 
-  #     obj = "a"
-  #     other = obj.dup
-  # 
-  #     obj == other      #=> true
-  #     obj.equal? other  #=> false
-  #     obj.equal? obj    #=> true
-  # 
-  # The `eql?` method returns `true` if `obj` and `other` refer to the same hash
-  # key.  This is used by Hash to test members for equality.  For objects of class
-  # `Object`, `eql?` is synonymous with `==`.  Subclasses normally continue this
-  # tradition by aliasing `eql?` to their overridden `==` method, but there are
-  # exceptions.  `Numeric` types, for example, perform type conversion across
-  # `==`, but not across `eql?`, so:
-  # 
-  #     1 == 1.0     #=> true
-  #     1.eql? 1.0   #=> false
-  # 
-  def eql?: (untyped) -> bool
-
-  # Adds to *obj* the instance methods from each module given as a parameter.
-  # 
-  #     module Mod
-  #       def hello
-  #         "Hello from Mod.\n"
-  #       end
-  #     end
-  # 
-  #     class Klass
-  #       def hello
-  #         "Hello from Klass.\n"
-  #       end
-  #     end
-  # 
-  #     k = Klass.new
-  #     k.hello         #=> "Hello from Klass.\n"
-  #     k.extend(Mod)   #=> #<Klass:0x401b3bc8>
-  #     k.hello         #=> "Hello from Mod.\n"
-  # 
-  def `extend`: (*Module) -> self
-
-  # Prevents further modifications to *obj*. A `RuntimeError` will be raised if
-  # modification is attempted. There is no way to unfreeze a frozen object. See
-  # also `Object#frozen?`.
-  # 
-  # This method returns self.
-  # 
-  #     a = [ "a", "b", "c" ]
-  #     a.freeze
-  #     a << "z"
-  # 
-  # *produces:*
-  # 
-  #     prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
-  #      from prog.rb:3
-  # 
-  # Objects of the following classes are always frozen: Integer, Float, Symbol.
-  # 
-  def freeze: () -> self
-
-  # Returns the freeze status of *obj*.
-  # 
-  #     a = [ "a", "b", "c" ]
-  #     a.freeze    #=> ["a", "b", "c"]
-  #     a.frozen?   #=> true
-  # 
-  def frozen?: () -> bool
-
-  def hash: () -> Integer
-
-  # Returns a string containing a human-readable representation of *obj*. The
-  # default `inspect` shows the object's class name, an encoding of the object id,
-  # and a list of the instance variables and their values (by calling #inspect on
-  # each of them). User defined classes should override this method to provide a
-  # better representation of *obj*.  When overriding this method, it should return
-  # a string whose encoding is compatible with the default external encoding.
-  # 
-  #     [ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
-  #     Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"
-  # 
-  #     class Foo
-  #     end
-  #     Foo.new.inspect                  #=> "#<Foo:0x0300c868>"
-  # 
-  #     class Bar
-  #       def initialize
-  #         @bar = 1
-  #       end
-  #     end
-  #     Bar.new.inspect                  #=> "#<Bar:0x0300c868 @bar=1>"
-  # 
-  def inspect: () -> String
-
-  # Returns `true` if *obj* is an instance of the given class. See also
-  # `Object#kind_of?`.
-  # 
-  #     class A;     end
-  #     class B < A; end
-  #     class C < B; end
-  # 
-  #     b = B.new
-  #     b.instance_of? A   #=> false
-  #     b.instance_of? B   #=> true
-  #     b.instance_of? C   #=> false
-  # 
-  def instance_of?: (Module) -> bool
-
-  # Returns `true` if the given instance variable is defined in *obj*. String
-  # arguments are converted to symbols.
-  # 
-  #     class Fred
-  #       def initialize(p1, p2)
-  #         @a, @b = p1, p2
-  #       end
-  #     end
-  #     fred = Fred.new('cat', 99)
-  #     fred.instance_variable_defined?(:@a)    #=> true
-  #     fred.instance_variable_defined?("@b")   #=> true
-  #     fred.instance_variable_defined?("@c")   #=> false
-  # 
-  def instance_variable_defined?: (String | Symbol var) -> bool
-
-  # Returns the value of the given instance variable, or nil if the instance
-  # variable is not set. The `@` part of the variable name should be included for
-  # regular instance variables. Throws a `NameError` exception if the supplied
-  # symbol is not valid as an instance variable name. String arguments are
-  # converted to symbols.
-  # 
-  #     class Fred
-  #       def initialize(p1, p2)
-  #         @a, @b = p1, p2
-  #       end
-  #     end
-  #     fred = Fred.new('cat', 99)
-  #     fred.instance_variable_get(:@a)    #=> "cat"
-  #     fred.instance_variable_get("@b")   #=> 99
-  # 
-  def instance_variable_get: (String | Symbol var) -> untyped
-
-  # Sets the instance variable named by *symbol* to the given object, thereby
-  # frustrating the efforts of the class's author to attempt to provide proper
-  # encapsulation. The variable does not have to exist prior to this call. If the
-  # instance variable name is passed as a string, that string is converted to a
-  # symbol.
-  # 
-  #     class Fred
-  #       def initialize(p1, p2)
-  #         @a, @b = p1, p2
-  #       end
-  #     end
-  #     fred = Fred.new('cat', 99)
-  #     fred.instance_variable_set(:@a, 'dog')   #=> "dog"
-  #     fred.instance_variable_set(:@c, 'cat')   #=> "cat"
-  #     fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
-  # 
-  def instance_variable_set: [X] (String | Symbol var, X value) -> X
-
-  # Returns an array of instance variable names for the receiver. Note that simply
-  # defining an accessor does not create the corresponding instance variable.
-  # 
-  #     class Fred
-  #       attr_accessor :a1
-  #       def initialize
-  #         @iv = 3
-  #       end
-  #     end
-  #     Fred.new.instance_variables   #=> [:@iv]
-  # 
-  def instance_variables: () -> Array[Symbol]
-
-  # Returns `true` if *class* is the class of *obj*, or if *class* is one of the
-  # superclasses of *obj* or modules included in *obj*.
-  # 
-  #     module M;    end
-  #     class A
-  #       include M
-  #     end
-  #     class B < A; end
-  #     class C < B; end
-  # 
-  #     b = B.new
-  #     b.is_a? A          #=> true
-  #     b.is_a? B          #=> true
-  #     b.is_a? C          #=> false
-  #     b.is_a? M          #=> true
-  # 
-  #     b.kind_of? A       #=> true
-  #     b.kind_of? B       #=> true
-  #     b.kind_of? C       #=> false
-  #     b.kind_of? M       #=> true
-  # 
-  def is_a?: (Module) -> bool
-
-  # Returns `true` if *class* is the class of *obj*, or if *class* is one of the
-  # superclasses of *obj* or modules included in *obj*.
-  # 
-  #     module M;    end
-  #     class A
-  #       include M
-  #     end
-  #     class B < A; end
-  #     class C < B; end
-  # 
-  #     b = B.new
-  #     b.is_a? A          #=> true
-  #     b.is_a? B          #=> true
-  #     b.is_a? C          #=> false
-  #     b.is_a? M          #=> true
-  # 
-  #     b.kind_of? A       #=> true
-  #     b.kind_of? B       #=> true
-  #     b.kind_of? C       #=> false
-  #     b.kind_of? M       #=> true
-  # 
-  alias kind_of? is_a?
-
-  # Returns the receiver.
-  # 
-  #     string = "my string"
-  #     string.itself.object_id == string.object_id   #=> true
-  # 
-  def `itself`: () -> self
-
-  # Looks up the named method as a receiver in *obj*, returning a `Method` object
-  # (or raising `NameError`). The `Method` object acts as a closure in *obj*'s
-  # object instance, so instance variables and the value of `self` remain
-  # available.
-  # 
-  #     class Demo
-  #       def initialize(n)
-  #         @iv = n
-  #       end
-  #       def hello()
-  #         "Hello, @iv = #{@iv}"
-  #       end
-  #     end
-  # 
-  #     k = Demo.new(99)
-  #     m = k.method(:hello)
-  #     m.call   #=> "Hello, @iv = 99"
-  # 
-  #     l = Demo.new('Fred')
-  #     m = l.method("hello")
-  #     m.call   #=> "Hello, @iv = Fred"
-  # 
-  # Note that `Method` implements `to_proc` method, which means it can be used
-  # with iterators.
-  # 
-  #     [ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout
-  # 
-  #     out = File.open('test.txt', 'w')
-  #     [ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file
-  # 
-  #     require 'date'
-  #     %w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
-  #     #=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]
-  # 
-  def method: (String | Symbol name) -> Method
-
-  # Returns a list of the names of public and protected methods of *obj*. This
-  # will include all the methods accessible in *obj*'s ancestors. If the optional
-  # parameter is `false`, it returns an array of *obj<i>'s public and protected
-  # singleton methods, the array will not include methods in modules included in
-  # <i>obj*.
-  # 
-  #     class Klass
-  #       def klass_method()
-  #       end
-  #     end
-  #     k = Klass.new
-  #     k.methods[0..9]    #=> [:klass_method, :nil?, :===,
-  #                        #    :==~, :!, :eql?
-  #                        #    :hash, :<=>, :class, :singleton_class]
-  #     k.methods.length   #=> 56
-  # 
-  #     k.methods(false)   #=> []
-  #     def k.singleton_method; end
-  #     k.methods(false)   #=> [:singleton_method]
-  # 
-  #     module M123; def m123; end end
-  #     k.extend M123
-  #     k.methods(false)   #=> [:singleton_method]
-  # 
-  def methods: () -> Array[Symbol]
-
-  # Only the object *nil* responds `true` to `nil?`.
-  # 
-  #     Object.new.nil?   #=> false
-  #     nil.nil?          #=> true
-  # 
-  def `nil?`: () -> bool
-
-  # Returns an integer identifier for `obj`.
-  # 
-  # The same number will be returned on all calls to `object_id` for a given
-  # object, and no two active objects will share an id.
-  # 
-  # Note: that some objects of builtin classes are reused for optimization. This
-  # is the case for immediate values and frozen string literals.
-  # 
-  # Immediate values are not passed by reference but are passed by value: `nil`,
-  # `true`, `false`, Fixnums, Symbols, and some Floats.
-  # 
-  #     Object.new.object_id  == Object.new.object_id  # => false
-  #     (21 * 2).object_id    == (21 * 2).object_id    # => true
-  #     "hello".object_id     == "hello".object_id     # => false
-  #     "hi".freeze.object_id == "hi".freeze.object_id # => true
-  # 
-  def object_id: () -> Integer
-
-  # Returns the list of private methods accessible to *obj*. If the *all*
-  # parameter is set to `false`, only those methods in the receiver will be
-  # listed.
-  # 
-  def private_methods: () -> Array[Symbol]
-
-  # Returns the list of protected methods accessible to *obj*. If the *all*
-  # parameter is set to `false`, only those methods in the receiver will be
-  # listed.
-  # 
-  def protected_methods: () -> Array[Symbol]
-
-  # Similar to *method*, searches public method only.
-  # 
-  def public_method: (name name) -> Method
-
-  # Invokes the method identified by *symbol*, passing it any arguments specified.
-  # Unlike send, public_send calls public methods only. When the method is
-  # identified by a string, the string is converted to a symbol.
-  # 
-  #     1.public_send(:puts, "hello")  # causes NoMethodError
-  # 
-  def `public_send`: (name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
-
-  # Removes the named instance variable from *obj*, returning that variable's
-  # value. String arguments are converted to symbols.
-  # 
-  #     class Dummy
-  #       attr_reader :var
-  #       def initialize
-  #         @var = 99
-  #       end
-  #       def remove
-  #         remove_instance_variable(:@var)
-  #       end
-  #     end
-  #     d = Dummy.new
-  #     d.var      #=> 99
-  #     d.remove   #=> 99
-  #     d.var      #=> nil
-  # 
-  def remove_instance_variable: (name name) -> untyped
-
-  # Returns `true` if *obj* responds to the given method.  Private and protected
-  # methods are included in the search only if the optional second parameter
-  # evaluates to `true`.
-  # 
-  # If the method is not implemented, as Process.fork on Windows, File.lchmod on
-  # GNU/Linux, etc., false is returned.
-  # 
-  # If the method is not defined, `respond_to_missing?` method is called and the
-  # result is returned.
-  # 
-  # When the method name parameter is given as a string, the string is converted
-  # to a symbol.
-  # 
-  def respond_to?: (name name, ?bool include_all) -> bool
-
-  # Invokes the method identified by *symbol*, passing it any arguments specified.
-  # You can use `__send__` if the name `send` clashes with an existing method in
-  # *obj*. When the method is identified by a string, the string is converted to a
-  # symbol.
-  # 
-  #     class Klass
-  #       def hello(*args)
-  #         "Hello " + args.join(' ')
-  #       end
-  #     end
-  #     k = Klass.new
-  #     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
-  # 
-  def `send`: (name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
-
-  # Returns the singleton class of *obj*.  This method creates a new singleton
-  # class if *obj* does not have one.
-  # 
-  # If *obj* is `nil`, `true`, or `false`, it returns NilClass, TrueClass, or
-  # FalseClass, respectively. If *obj* is an Integer, a Float or a Symbol, it
-  # raises a TypeError.
-  # 
-  #     Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
-  #     String.singleton_class      #=> #<Class:String>
-  #     nil.singleton_class         #=> NilClass
-  # 
-  def `singleton_class`: () -> Class
-
-  # Similar to *method*, searches singleton method only.
-  # 
-  #     class Demo
-  #       def initialize(n)
-  #         @iv = n
-  #       end
-  #       def hello()
-  #         "Hello, @iv = #{@iv}"
-  #       end
-  #     end
-  # 
-  #     k = Demo.new(99)
-  #     def k.hi
-  #       "Hi, @iv = #{@iv}"
-  #     end
-  #     m = k.singleton_method(:hi)
-  #     m.call   #=> "Hi, @iv = 99"
-  #     m = k.singleton_method(:hello) #=> NameError
-  # 
-  def singleton_method: (name name) -> Method
-
-  # Returns an array of the names of singleton methods for *obj*. If the optional
-  # *all* parameter is true, the list will include methods in modules included in
-  # *obj*. Only public and protected singleton methods are returned.
-  # 
-  #     module Other
-  #       def three() end
-  #     end
-  # 
-  #     class Single
-  #       def Single.four() end
-  #     end
-  # 
-  #     a = Single.new
-  # 
-  #     def a.one()
-  #     end
-  # 
-  #     class << a
-  #       include Other
-  #       def two()
-  #       end
-  #     end
-  # 
-  #     Single.singleton_methods    #=> [:four]
-  #     a.singleton_methods(false)  #=> [:two, :one]
-  #     a.singleton_methods         #=> [:two, :one, :three]
-  # 
-  def singleton_methods: () -> Array[Symbol]
-
-  # Mark the object as tainted.
-  # 
-  # Objects that are marked as tainted will be restricted from various built-in
-  # methods. This is to prevent insecure data, such as command-line arguments or
-  # strings read from Kernel#gets, from inadvertently compromising the user's
-  # system.
-  # 
-  # To check whether an object is tainted, use #tainted?.
-  # 
-  # You should only untaint a tainted object if your code has inspected it and
-  # determined that it is safe. To do so use #untaint.
-  # 
-  def taint: () -> self
-
-  # Deprecated method that is equivalent to #taint.
-  # 
-  alias untrust taint
-
-  # Returns true if the object is tainted.
-  # 
-  # See #taint for more information.
-  # 
-  def tainted?: () -> bool
-
-  # Deprecated method that is equivalent to #tainted?.
-  # 
-  alias untrusted? tainted?
-
-  # Yields self to the block, and then returns self. The primary purpose of this
-  # method is to "tap into" a method chain, in order to perform operations on
-  # intermediate results within the chain.
-  # 
-  #     (1..10)                  .tap {|x| puts "original: #{x}" }
-  #       .to_a                  .tap {|x| puts "array:    #{x}" }
-  #       .select {|x| x.even? } .tap {|x| puts "evens:    #{x}" }
-  #       .map {|x| x*x }        .tap {|x| puts "squares:  #{x}" }
-  # 
-  def tap: () { (self) -> void } -> self
-
-  # Yields self to the block and returns the result of the block.
-  # 
-  #     3.next.then {|x| x**x }.to_s             #=> "256"
-  #     "my string".yield_self {|s| s.upcase }   #=> "MY STRING"
-  # 
-  # Good usage for `yield_self` is value piping in method chains:
-  # 
-  #     require 'open-uri'
-  #     require 'json'
-  # 
-  #     construct_url(arguments).
-  #       yield_self {|url| open(url).read }.
-  #       yield_self {|response| JSON.parse(response) }
-  # 
-  # When called without block, the method returns `Enumerator`, which can be used,
-  # for example, for conditional circuit-breaking:
-  # 
-  #     # meets condition, no-op
-  #     1.yield_self.detect(&:odd?)            # => 1
-  #     # does not meet condition, drop value
-  #     2.yield_self.detect(&:odd?)            # => nil
-  # 
-  def `yield_self`: [X] () { (self) -> X } -> X
-                  | () -> Enumerator[self, untyped]
-
-  # Returns a string representing *obj*. The default `to_s` prints the object's
-  # class and an encoding of the object id. As a special case, the top-level
-  # object that is the initial execution context of Ruby programs returns
-  # ``main''.
-  # 
-  def to_s: () -> String
-
-  # Removes the tainted mark from the object.
-  # 
-  # See #taint for more information.
-  # 
-  def untaint: () -> self
-
-  # Deprecated method that is equivalent to #untaint.
-  # 
-  alias trust untaint
-
-  # Yields self to the block and returns the result of the block.
-  # 
-  #     3.next.then {|x| x**x }.to_s             #=> "256"
-  #     "my string".yield_self {|s| s.upcase }   #=> "MY STRING"
-  # 
-  # Good usage for `yield_self` is value piping in method chains:
-  # 
-  #     require 'open-uri'
-  #     require 'json'
-  # 
-  #     construct_url(arguments).
-  #       yield_self {|url| open(url).read }.
-  #       yield_self {|response| JSON.parse(response) }
-  # 
-  # When called without block, the method returns `Enumerator`, which can be used,
-  # for example, for conditional circuit-breaking:
-  # 
-  #     # meets condition, no-op
-  #     1.yield_self.detect(&:odd?)            # => 1
-  #     # does not meet condition, drop value
-  #     2.yield_self.detect(&:odd?)            # => nil
-  # 
-  alias then yield_self
-end
-
-interface _Writeable
-  def write: (untyped) -> void
-end
-
-type Object::name = Symbol | String