steep 0.13.0 → 0.16.2

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

@@ -1,404 +0,0 @@
-# The `Enumerable` mixin provides collection classes with several
-# traversal and searching methods, and with the ability to sort. The class
-# must provide a method `each`, which yields successive members of the
-# collection. If `Enumerable#max`, `#min`, or `#sort` is used, the
-# objects in the collection must also implement a meaningful `<=>`
-# operator, as these methods rely on an ordering between members of the
-# collection.
-module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
-  # Passes each element of the collection to the given block. The method
-  # returns `true` if the block never returns `false` or `nil` . If the
-  # block is not given, Ruby adds an implicit block of `{ |obj| obj }` which
-  # will cause [all?](Enumerable.downloaded.ruby_doc#method-i-all-3F) to
-  # return `true` when none of the collection members are `false` or `nil` .
-  # 
-  # If instead a pattern is supplied, the method returns whether `pattern
-  # === element` for every collection member.
-  # 
-  #     %w[ant bear cat].all? { |word| word.length >= 3 } #=> true
-  #     %w[ant bear cat].all? { |word| word.length >= 4 } #=> false
-  #     %w[ant bear cat].all?(/t/)                        #=> false
-  #     [1, 2i, 3.14].all?(Numeric)                       #=> true
-  #     [nil, true, 99].all?                              #=> false
-  #     [].all?                                           #=> true
-  def all?: () -> bool
-          | () { (Elem arg0) -> untyped } -> bool
-
-  # Passes each element of the collection to the given block. The method
-  # returns `true` if the block ever returns a value other than `false` or
-  # `nil` . If the block is not given, Ruby adds an implicit block of `{
-  # |obj| obj }` that will cause
-  # [any?](Enumerable.downloaded.ruby_doc#method-i-any-3F) to return `true`
-  # if at least one of the collection members is not `false` or `nil` .
-  # 
-  # If instead a pattern is supplied, the method returns whether `pattern
-  # === element` for any collection member.
-  # 
-  # ```ruby
-  # %w[ant bear cat].any? { |word| word.length >= 3 } #=> true
-  # %w[ant bear cat].any? { |word| word.length >= 4 } #=> true
-  # %w[ant bear cat].any?(/d/)                        #=> false
-  # [nil, true, 99].any?(Integer)                     #=> true
-  # [nil, true, 99].any?                              #=> true
-  # [].any?                                           #=> false
-  # ```
-  def `any?`: () -> bool
-            | () { (Elem arg0) -> untyped } -> bool
-
-  def collect: [U] () { (Elem arg0) -> U } -> ::Array[U]
-             | () -> ::Enumerator[Elem, Return]
-
-  def collect_concat: [U] () { (Elem arg0) -> ::Enumerator[U, untyped] } -> ::Array[U]
-
-  # Returns the number of items in `enum` through enumeration. If an
-  # argument is given, the number of items in `enum` that are equal to
-  # `item` are counted. If a block is given, it counts the number of
-  # elements yielding a true value.
-  # 
-  # ```ruby
-  # ary = [1, 2, 4, 2]
-  # ary.count               #=> 4
-  # ary.count(2)            #=> 2
-  # ary.count{ |x| x%2==0 } #=> 3
-  # ```
-  def count: () -> Integer
-           | (?untyped arg0) -> Integer
-           | () { (Elem arg0) -> untyped } -> Integer
-
-  def cycle: (?Integer n) { (Elem arg0) -> untyped } -> NilClass
-           | (?Integer n) -> ::Enumerator[Elem, Return]
-
-  def detect: (?Proc ifnone) { (Elem arg0) -> untyped } -> Elem?
-            | (?Proc ifnone) -> ::Enumerator[Elem, Return]
-
-  def drop: (Integer n) -> ::Array[Elem]
-
-  def drop_while: () { (Elem arg0) -> untyped } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, Return]
-
-  def each_cons: (Integer n) { (::Array[Elem] arg0) -> untyped } -> NilClass
-               | (Integer n) -> ::Enumerator[::Array[Elem], Return]
-
-  def each_with_index: () { (Elem arg0, Integer arg1) -> untyped } -> ::Enumerable[Elem, Return]
-                     | () -> ::Enumerator[[ Elem, Integer ], Return]
-
-  def each_with_object: [U] (U arg0) { (Elem arg0, untyped arg1) -> untyped } -> U
-                      | [U] (U arg0) -> ::Enumerator[[ Elem, U ], Return]
-
-  # Returns an array containing the items in *enum* .
-  # 
-  # ```ruby
-  # (1..7).to_a                       #=> [1, 2, 3, 4, 5, 6, 7]
-  # { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a   #=> [["a", 1], ["b", 2], ["c", 3]]
-  # 
-  # require 'prime'
-  # Prime.entries 10                  #=> [2, 3, 5, 7]
-  # ```
-  def entries: () -> ::Array[Elem]
-
-  def find_all: () { (Elem arg0) -> untyped } -> ::Array[Elem]
-              | () -> ::Enumerator[Elem, Return]
-
-  alias select find_all
-  alias filter find_all
-
-  def find_index: (?untyped value) -> Integer?
-                | () { (Elem arg0) -> untyped } -> Integer?
-                | () -> ::Enumerator[Elem, Return]
-
-  # Returns the first element, or the first `n` elements, of the enumerable.
-  # If the enumerable is empty, the first form returns `nil`, and the
-  # second form returns an empty array.
-  # 
-  # ```ruby
-  # %w[foo bar baz].first     #=> "foo"
-  # %w[foo bar baz].first(2)  #=> ["foo", "bar"]
-  # %w[foo bar baz].first(10) #=> ["foo", "bar", "baz"]
-  # [].first                  #=> nil
-  # [].first(10)              #=> []
-  # ```
-  def first: () -> Elem?
-           | (?Integer n) -> ::Array[Elem]?
-
-  def grep: (untyped arg0) -> ::Array[Elem]
-          | [U] (untyped arg0) { (Elem arg0) -> U } -> ::Array[U]
-
-  def grep_v: (untyped arg0) -> ::Array[Integer]
-            | [U] (untyped arg0) { (Elem arg0) -> U } -> ::Array[U]
-
-  def group_by: [U] () { (Elem arg0) -> U } -> ::Hash[U, ::Array[Elem]]
-              | () -> ::Enumerator[Elem, Return]
-
-  def `include?`: (untyped arg0) -> bool
-
-  def inject: (untyped init, Symbol method) -> untyped
-            | (Symbol method) -> untyped
-            | [A] (A initial) { (Elem, A) -> A } -> Elem
-            | () { (Elem, Elem) -> Elem } -> Elem
-
-  # Returns the object in *enum* with the maximum value. The first form
-  # assumes all objects implement `Comparable` ; the second uses the block
-  # to return *a \<=\> b* .
-  # 
-  # ```ruby
-  # a = %w(albatross dog horse)
-  # a.max                                   #=> "horse"
-  # a.max { |a, b| a.length <=> b.length }  #=> "albatross"
-  # ```
-  # 
-  # If the `n` argument is given, maximum `n` elements are returned as an
-  # array, sorted in descending order.
-  # 
-  # ```ruby
-  # a = %w[albatross dog horse]
-  # a.max(2)                                  #=> ["horse", "dog"]
-  # a.max(2) {|a, b| a.length <=> b.length }  #=> ["albatross", "horse"]
-  # [5, 1, 3, 4, 2].max(3)                    #=> [5, 4, 3]
-  # ```
-  def max: () -> Elem?
-         | () { (Elem arg0, Elem arg1) -> Integer } -> Elem?
-         | (?Integer arg0) -> ::Array[Elem]
-         | (?Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
-
-  def max_by: () -> ::Enumerator[Elem, Return]
-            | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
-            | (?Integer arg0) -> ::Enumerator[Elem, Return]
-            | (?Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
-
-  # Returns the object in *enum* with the minimum value. The first form
-  # assumes all objects implement `Comparable` ; the second uses the block
-  # to return *a \<=\> b* .
-  # 
-  # ```ruby
-  # a = %w(albatross dog horse)
-  # a.min                                   #=> "albatross"
-  # a.min { |a, b| a.length <=> b.length }  #=> "dog"
-  # ```
-  # 
-  # If the `n` argument is given, minimum `n` elements are returned as a
-  # sorted array.
-  # 
-  # ```ruby
-  # a = %w[albatross dog horse]
-  # a.min(2)                                  #=> ["albatross", "dog"]
-  # a.min(2) {|a, b| a.length <=> b.length }  #=> ["dog", "horse"]
-  # [5, 1, 3, 4, 2].min(3)                    #=> [1, 2, 3]
-  # ```
-  def min: () -> Elem?
-         | () { (Elem arg0, Elem arg1) -> Integer } -> Elem?
-         | (?Integer arg0) -> ::Array[Elem]
-         | (?Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
-
-  def min_by: () -> ::Enumerator[Elem, Return]
-            | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
-            | (?Integer arg0) -> ::Enumerator[Elem, Return]
-            | (?Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
-
-  # Returns a two element array which contains the minimum and the maximum
-  # value in the enumerable. The first form assumes all objects implement
-  # `Comparable` ; the second uses the block to return *a \<=\> b* .
-  # 
-  # ```ruby
-  # a = %w(albatross dog horse)
-  # a.minmax                                  #=> ["albatross", "horse"]
-  # a.minmax { |a, b| a.length <=> b.length } #=> ["dog", "albatross"]
-  # ```
-  def minmax: () -> [ Elem?, Elem? ]
-            | () { (Elem arg0, Elem arg1) -> Integer } -> [ Elem?, Elem? ]
-
-  def minmax_by: () -> [ Elem?, Elem? ]
-               | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Enumerator[Elem, Return]
-
-  # Passes each element of the collection to the given block. The method
-  # returns `true` if the block never returns `true` for all elements. If
-  # the block is not given, `none?` will return `true` only if none of the
-  # collection members is true.
-  # 
-  # If instead a pattern is supplied, the method returns whether `pattern
-  # === element` for none of the collection members.
-  # 
-  # ```ruby
-  # %w{ant bear cat}.none? { |word| word.length == 5 } #=> true
-  # %w{ant bear cat}.none? { |word| word.length >= 4 } #=> false
-  # %w{ant bear cat}.none?(/d/)                        #=> true
-  # [1, 3.14, 42].none?(Float)                         #=> false
-  # [].none?                                           #=> true
-  # [nil].none?                                        #=> true
-  # [nil, false].none?                                 #=> true
-  # [nil, false, true].none?                           #=> false
-  # ```
-  def none?: () -> bool
-           | () { (Elem arg0) -> untyped } -> bool
-
-  # Passes each element of the collection to the given block. The method
-  # returns `true` if the block returns `true` exactly once. If the block is
-  # not given, `one?` will return `true` only if exactly one of the
-  # collection members is true.
-  # 
-  # If instead a pattern is supplied, the method returns whether `pattern
-  # === element` for exactly one collection member.
-  # 
-  # ```ruby
-  # %w{ant bear cat}.one? { |word| word.length == 4 }  #=> true
-  # %w{ant bear cat}.one? { |word| word.length > 4 }   #=> false
-  # %w{ant bear cat}.one? { |word| word.length < 4 }   #=> false
-  # %w{ant bear cat}.one?(/t/)                         #=> false
-  # [ nil, true, 99 ].one?                             #=> false
-  # [ nil, true, false ].one?                          #=> true
-  # [ nil, true, 99 ].one?(Integer)                    #=> true
-  # [].one?                                            #=> false
-  # ```
-  def one?: () -> bool
-          | () { (Elem arg0) -> untyped } -> bool
-
-  def partition: () { (Elem arg0) -> untyped } -> [ ::Array[Elem], ::Array[Elem] ]
-               | () -> ::Enumerator[Elem, Return]
-
-  def reject: () { (Elem arg0) -> untyped } -> ::Array[Elem]
-            | () -> ::Enumerator[Elem, Return]
-
-  def reverse_each: () { (Elem arg0) -> untyped } -> ::Enumerator[Elem, Return]
-                  | () -> ::Enumerator[Elem, Return]
-
-  # Returns an array containing the items in *enum* sorted.
-  # 
-  # Comparisons for the sort will be done using the items’ own `<=>`
-  # operator or using an optional code block.
-  # 
-  # The block must implement a comparison between `a` and `b` and return an
-  # integer less than 0 when `b` follows `a`, `0` when `a` and `b` are
-  # equivalent, or an integer greater than 0 when `a` follows `b` .
-  # 
-  # The result is not guaranteed to be stable. When the comparison of two
-  # elements returns `0`, the order of the elements is unpredictable.
-  # 
-  # ```ruby
-  # %w(rhea kea flea).sort           #=> ["flea", "kea", "rhea"]
-  # (1..10).sort { |a, b| b <=> a }  #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
-  # ```
-  # 
-  # See also [\#sort\_by](Enumerable.downloaded.ruby_doc#method-i-sort_by).
-  # It implements a Schwartzian transform which is useful when key
-  # computation or comparison is expensive.
-  def sort: () -> ::Array[Elem]
-          | () { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
-
-  def sort_by: () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
-             | () -> ::Enumerator[Elem, Return]
-
-  def take: (Integer n) -> ::Array[Elem]?
-
-  def take_while: () { (Elem arg0) -> untyped } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, Return]
-
-  # Implemented in C++
-  # Returns the result of interpreting *enum* as a list of `[key, value]`
-  # pairs.
-  # 
-  #     %i[hello world].each_with_index.to_h
-  #       # => {:hello => 0, :world => 1}
-  # 
-  # If a block is given, the results of the block on each element of the
-  # enum will be used as pairs.
-  # 
-  # ```ruby
-  # (1..5).to_h {|x| [x, x ** 2]}
-  #   #=> {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}
-  # ```
-  def to_h: () -> ::Hash[untyped, untyped]
-
-  def each_slice: (Integer n) { (::Array[Elem] arg0) -> untyped } -> NilClass
-                | (Integer n) -> ::Enumerator[::Array[Elem], Return]
-
-  def find: (?Proc ifnone) { (Elem arg0) -> untyped } -> Elem?
-          | (?Proc ifnone) -> ::Enumerator[Elem, Return]
-
-  def flat_map: [U] () { (Elem arg0) -> U } -> U
-              | () -> ::Enumerator[Elem, Return]
-
-  def map: [U] () { (Elem arg0) -> U } -> ::Array[U]
-         | () -> ::Enumerator[Elem, Return]
-
-  def member?: (untyped arg0) -> bool
-
-  alias reduce inject
-
-  # Returns an array containing the items in *enum* .
-  # 
-  # ```ruby
-  # (1..7).to_a                       #=> [1, 2, 3, 4, 5, 6, 7]
-  # { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a   #=> [["a", 1], ["b", 2], ["c", 3]]
-  # 
-  # require 'prime'
-  # Prime.entries 10                  #=> [2, 3, 5, 7]
-  # ```
-  def to_a: () -> ::Array[Elem]
-
-  # Returns a lazy enumerator, whose methods map/collect,
-  # flat\_map/collect\_concat, select/find\_all, reject, grep,
-  # [\#grep\_v](Enumerable.downloaded.ruby_doc#method-i-grep_v), zip, take,
-  # [\#take\_while](Enumerable.downloaded.ruby_doc#method-i-take_while),
-  # drop, and
-  # [\#drop\_while](Enumerable.downloaded.ruby_doc#method-i-drop_while)
-  # enumerate values only on an as-needed basis. However, if a block is
-  # given to zip, values are enumerated immediately.
-  # 
-  # 
-  # The following program finds pythagorean triples:
-  # 
-  # ```ruby
-  # def pythagorean_triples
-  #   (1..Float::INFINITY).lazy.flat_map {|z|
-  #     (1..z).flat_map {|x|
-  #       (x..z).select {|y|
-  #         x**2 + y**2 == z**2
-  #       }.map {|y|
-  #         [x, y, z]
-  #       }
-  #     }
-  #   }
-  # end
-  # # show first ten pythagorean triples
-  # p pythagorean_triples.take(10).force # take is lazy, so force is needed
-  # p pythagorean_triples.first(10)      # first is eager
-  # # show pythagorean triples less than 100
-  # p pythagorean_triples.take_while { |*, z| z < 100 }.force
-  # ```
-  def lazy: () -> Enumerator::Lazy[Elem, Return]
-
-  def uniq: () -> ::Array[Elem]
-          | () { (Elem item) -> untyped } -> ::Array[Elem]
-
-  def sum: () -> (Elem | Integer)
-         | [T] () { (Elem arg0) -> T } -> (Integer | T)
-         | [T] (?T arg0) -> (Elem | T)
-         | [U] (?U arg0) { (Elem arg0) -> U } -> U
-
-  def filter_map: [U] () { (Elem arg0) -> U? } -> ::Array[U]
-                | () -> ::Enumerator[Elem, Return]
-
-  def chain: (*self enumerables) -> ::Enumerator::Chain[Elem, ::Array[self]]
-
-  def tally: () -> ::Hash[Elem, Integer]
-
-  def each_entry: () -> ::Enumerator[Elem, Return]
-                | () { (Elem arg0) -> untyped } -> self
-
-  # variadic type parameter is not supported yet
-  # https://github.com/ruby/ruby-signature/issues/21
-  def zip: [Elem2, Return2] (::Enumerable[Elem2, Return2] enum) -> ::Array[[Elem, Elem2 | nil]]
-         | [U, Elem2, Return2] (::Enumerable[Elem2, Return2]) { ([Elem, Elem2 | nil]) -> U } -> nil
-
-  def chunk: () -> ::Enumerator[Elem, Return]
-           | [U] () { (Elem elt) -> U } -> ::Enumerator[[U, Array[Elem]], void]
-
-  def chunk_while: () { (Elem elt_before, Elem elt_after) -> bool } -> ::Enumerator[::Array[Elem], void]
-
-  def slice_when: () { (Elem elt_before, Elem elt_after) -> bool } -> ::Enumerator[::Array[Elem], void]
-
-  def slice_after: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
-                 | () { (Elem elt) -> bool } -> ::Enumerator[::Array[Elem], void]
-
-  def slice_before: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
-                  | () { (Elem elt) -> bool } -> ::Enumerator[::Array[Elem], void]
-end

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

@@ -1,260 +0,0 @@
-# A class which allows both internal and external iteration.
-# 
-# An [Enumerator](Enumerator) can be created by the
-# following methods.
-# 
-#   - Kernel\#to\_enum
-# 
-#   - Kernel\#enum\_for
-# 
-#   - [::new](Enumerator#method-c-new)
-# 
-# Most methods have two forms: a block form where the contents are
-# evaluated for each item in the enumeration, and a non-block form which
-# returns a new [Enumerator](Enumerator) wrapping the
-# iteration.
-# 
-# ```ruby
-# enumerator = %w(one two three).each
-# puts enumerator.class # => Enumerator
-# 
-# enumerator.each_with_object("foo") do |item, obj|
-#   puts "#{obj}: #{item}"
-# end
-# 
-# # foo: one
-# # foo: two
-# # foo: three
-# 
-# enum_with_obj = enumerator.each_with_object("foo")
-# puts enum_with_obj.class # => Enumerator
-# 
-# enum_with_obj.each do |item, obj|
-#   puts "#{obj}: #{item}"
-# end
-# 
-# # foo: one
-# # foo: two
-# # foo: three
-# ```
-# 
-# This allows you to chain Enumerators together. For example, you can map
-# a list's elements to strings containing the index and the element as a
-# string via:
-# 
-# ```ruby
-# puts %w[foo bar baz].map.with_index { |w, i| "#{i}:#{w}" }
-# # => ["0:foo", "1:bar", "2:baz"]
-# ```
-# 
-# An [Enumerator](Enumerator) can also be used as an
-# external iterator. For example,
-# [\#next](Enumerator#method-i-next) returns the next
-# value of the iterator or raises
-# [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) if
-# the [Enumerator](Enumerator) is at the end.
-# 
-# ```ruby
-# e = [1,2,3].each   # returns an enumerator object.
-# puts e.next   # => 1
-# puts e.next   # => 2
-# puts e.next   # => 3
-# puts e.next   # raises StopIteration
-# ```
-# 
-# You can use this to implement an internal iterator as follows:
-# 
-# ```ruby
-# def ext_each(e)
-#   while true
-#     begin
-#       vs = e.next_values
-#     rescue StopIteration
-#       return $!.result
-#     end
-#     y = yield(*vs)
-#     e.feed y
-#   end
-# end
-# 
-# o = Object.new
-# 
-# def o.each
-#   puts yield
-#   puts yield(1)
-#   puts yield(1, 2)
-#   3
-# end
-# 
-# # use o.each as an internal iterator directly.
-# puts o.each {|*x| puts x; [:b, *x] }
-# # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
-# 
-# # convert o.each to an external iterator for
-# # implementing an internal iterator.
-# puts ext_each(o.to_enum) {|*x| puts x; [:b, *x] }
-# # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
-# ```
-class Enumerator[unchecked out Elem, out Return] < Object
-  include Enumerable[Elem, Return]
-
-  def each: () { (Elem arg0) -> untyped } -> Return
-          | () -> self
-
-  def feed: (Elem arg0) -> NilClass
-
-  def initialize: (?Integer arg0) { (Enumerator::Yielder arg0) -> void } -> void
-
-  # Creates a printable version of *e* .
-  def inspect: () -> String
-
-  # Returns the next object in the enumerator, and move the internal
-  # position forward. When the position reached at the end,
-  # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
-  # raised.
-  # 
-  # 
-  # ```ruby
-  # a = [1,2,3]
-  # e = a.to_enum
-  # p e.next   #=> 1
-  # p e.next   #=> 2
-  # p e.next   #=> 3
-  # p e.next   #raises StopIteration
-  # ```
-  # 
-  # Note that enumeration sequence by `next` does not affect other
-  # non-external enumeration methods, unless the underlying iteration
-  # methods itself has side-effect, e.g.
-  # [IO\#each\_line](https://ruby-doc.org/core-2.6.3/IO.html#method-i-each_line)
-  # .
-  def next: () -> Elem
-
-  # Returns the next object as an array in the enumerator, and move the
-  # internal position forward. When the position reached at the end,
-  # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
-  # raised.
-  # 
-  # This method can be used to distinguish `yield` and `yield nil` .
-  # 
-  # 
-  # ```ruby
-  # o = Object.new
-  # def o.each
-  #   yield
-  #   yield 1
-  #   yield 1, 2
-  #   yield nil
-  #   yield [1, 2]
-  # end
-  # e = o.to_enum
-  # p e.next_values
-  # p e.next_values
-  # p e.next_values
-  # p e.next_values
-  # p e.next_values
-  # e = o.to_enum
-  # p e.next
-  # p e.next
-  # p e.next
-  # p e.next
-  # p e.next
-  # 
-  # ## yield args       next_values      next
-  # #  yield            []               nil
-  # #  yield 1          [1]              1
-  # #  yield 1, 2       [1, 2]           [1, 2]
-  # #  yield nil        [nil]            nil
-  # #  yield [1, 2]     [[1, 2]]         [1, 2]
-  # ```
-  # 
-  # Note that `next_values` does not affect other non-external enumeration
-  # methods unless underlying iteration method itself has side-effect, e.g.
-  # [IO\#each\_line](https://ruby-doc.org/core-2.6.3/IO.html#method-i-each_line)
-  # .
-  def next_values: () -> ::Array[Elem]
-
-  # Returns the next object in the enumerator, but doesn’t move the internal
-  # position forward. If the position is already at the end,
-  # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
-  # raised.
-  # 
-  # 
-  # ```ruby
-  # a = [1,2,3]
-  # e = a.to_enum
-  # p e.next   #=> 1
-  # p e.peek   #=> 2
-  # p e.peek   #=> 2
-  # p e.peek   #=> 2
-  # p e.next   #=> 2
-  # p e.next   #=> 3
-  # p e.peek   #raises StopIteration
-  # ```
-  def peek: () -> Elem
-
-  # Returns the next object as an array, similar to
-  # [\#next\_values](Enumerator.downloaded.ruby_doc#method-i-next_values),
-  # but doesn’t move the internal position forward. If the position is
-  # already at the end,
-  # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
-  # raised.
-  # 
-  # 
-  # ```ruby
-  # o = Object.new
-  # def o.each
-  #   yield
-  #   yield 1
-  #   yield 1, 2
-  # end
-  # e = o.to_enum
-  # p e.peek_values    #=> []
-  # e.next
-  # p e.peek_values    #=> [1]
-  # p e.peek_values    #=> [1]
-  # e.next
-  # p e.peek_values    #=> [1, 2]
-  # e.next
-  # p e.peek_values    # raises StopIteration
-  # ```
-  def peek_values: () -> ::Array[Elem]
-
-  # Rewinds the enumeration sequence to the beginning.
-  # 
-  # If the enclosed object responds to a “rewind” method, it is called.
-  def rewind: () -> self
-
-  # Returns the size of the enumerator, or `nil` if it can’t be calculated
-  # lazily.
-  # 
-  # ```ruby
-  # (1..100).to_a.permutation(4).size # => 94109400
-  # loop.size # => Float::INFINITY
-  # (1..100).drop_while.size # => nil
-  # ```
-  def size: () -> (Integer | Float)?
-
-  def with_index: (?Integer offset) { (Elem arg0, Integer arg1) -> untyped } -> Return
-                | (?Integer offset) -> ::Enumerator[[ Elem, Integer ], Return]
-
-  def with_object: [U] (U arg0) { (Elem arg0, U arg1) -> untyped } -> U
-                 | [U] (U arg0) -> ::Enumerator[[ Elem, U ], Return]
-end
-
-class Enumerator::Generator[out Elem, out Return] < Object
-  include Enumerable[Elem, Return]
-end
-
-class Enumerator::Lazy[out Elem, out Return] < Enumerator[Elem, Return]
-end
-
-class Enumerator::Yielder < Object
-  def <<: (*untyped arg0) -> void
-
-  def yield: (*untyped arg0) -> void
-end
-
-class Enumerator::Chain[out Elem, out Return] < Object
-  include Enumerable[Elem, Return]
-end