rbs 4.1.0.pre.2-java

data/core/enumerator.rbs

@@ -0,0 +1,705 @@
+# <!-- rdoc-file=enumerator.c -->
+# A class which allows both internal and external iteration.
+#
+# An Enumerator can be created by the following methods.
+# *   Object#to_enum
+# *   Object#enum_for
+# *   Enumerator.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 wrapping the iteration.
+#
+#     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:
+#
+#     puts %w[foo bar baz].map.with_index { |w, i| "#{i}:#{w}" }
+#     # => ["0:foo", "1:bar", "2:baz"]
+#
+# ## External Iteration
+#
+# An Enumerator can also be used as an external iterator. For example,
+# Enumerator#next returns the next value of the iterator or raises StopIteration
+# if the Enumerator is at the end.
+#
+#     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
+#
+# `next`, `next_values`, `peek`, and `peek_values` are the only methods which
+# use external iteration (and Array#zip(Enumerable-not-Array) which uses `next`
+# internally).
+#
+# These methods do not affect other internal enumeration methods, unless the
+# underlying iteration method itself has side-effect, e.g. IO#each_line.
+#
+# FrozenError will be raised if these methods are called against a frozen
+# enumerator. Since `rewind` and `feed` also change state for external
+# iteration, these methods may raise FrozenError too.
+#
+# External iteration differs **significantly** from internal iteration due to
+# using a Fiber:
+# *   The Fiber adds some overhead compared to internal enumeration.
+# *   The stacktrace will only include the stack from the Enumerator, not above.
+# *   Fiber-local variables are **not** inherited inside the Enumerator Fiber,
+#     which instead starts with no Fiber-local variables.
+# *   Fiber storage variables **are** inherited and are designed to handle
+#     Enumerator Fibers. Assigning to a Fiber storage variable only affects the
+#     current Fiber, so if you want to change state in the caller Fiber of the
+#     Enumerator Fiber, you need to use an extra indirection (e.g., use some
+#     object in the Fiber storage variable and mutate some ivar of it).
+#
+# Concretely:
+#
+#     Thread.current[:fiber_local] = 1
+#     Fiber[:storage_var] = 1
+#     e = Enumerator.new do |y|
+#       p Thread.current[:fiber_local] # for external iteration: nil, for internal iteration: 1
+#       p Fiber[:storage_var] # => 1, inherited
+#       Fiber[:storage_var] += 1
+#       y << 42
+#     end
+#
+#     p e.next # => 42
+#     p Fiber[:storage_var] # => 1 (it ran in a different Fiber)
+#
+#     e.each { p _1 }
+#     p Fiber[:storage_var] # => 2 (it ran in the same Fiber/"stack" as the current Fiber)
+#
+# ## Convert External Iteration to Internal Iteration
+#
+# You can use an external iterator to implement an internal iterator as follows:
+#
+#     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 E, out R = void] < Object
+  include Enumerable[E]
+
+  # A convenience interface for `each` with optional block
+  #
+  interface _Each[out T, out R]
+    def each: () { (T) -> void } -> R
+            | () -> Enumerator[T, R]
+  end
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - Enumerator.produce(initial = nil, size: nil) { |prev| block } -> enumerator
+  # -->
+  # Creates an infinite enumerator from any block, just called over and over.  The
+  # result of the previous iteration is passed to the next one. If `initial` is
+  # provided, it is passed to the first iteration, and becomes the first element
+  # of the enumerator; if it is not provided, the first iteration receives `nil`,
+  # and its result becomes the first element of the iterator.
+  #
+  # Raising StopIteration from the block stops an iteration.
+  #
+  #     Enumerator.produce(1, &:succ)   # => enumerator of 1, 2, 3, 4, ....
+  #
+  #     Enumerator.produce { rand(10) } # => infinite random number sequence
+  #
+  #     ancestors = Enumerator.produce(node) { |prev| node = prev.parent or raise StopIteration }
+  #     enclosing_section = ancestors.find { |n| n.type == :section }
+  #
+  # Using ::produce together with Enumerable methods like Enumerable#detect,
+  # Enumerable#slice_after, Enumerable#take_while can provide Enumerator-based
+  # alternatives for `while` and `until` cycles:
+  #
+  #     # Find next Tuesday
+  #     require "date"
+  #     Enumerator.produce(Date.today, &:succ).detect(&:tuesday?)
+  #
+  #     # Simple lexer:
+  #     require "strscan"
+  #     scanner = StringScanner.new("7+38/6")
+  #     PATTERN = %r{\d+|[-/+*]}
+  #     Enumerator.produce { scanner.scan(PATTERN) }.slice_after { scanner.eos? }.first
+  #     # => ["7", "+", "38", "/", "6"]
+  #
+  # The optional `size` keyword argument specifies the size of the enumerator,
+  # which can be retrieved by Enumerator#size.  It can be an integer,
+  # <code>Float::INFINITY</code>, a callable object (such as a lambda), or `nil`
+  # to indicate unknown size.  When not specified, the size defaults to
+  # <code>Float::INFINITY</code>.
+  #
+  #     # Infinite enumerator
+  #     enum = Enumerator.produce(1, size: Float::INFINITY, &:succ)
+  #     enum.size  # => Float::INFINITY
+  #
+  #     # Finite enumerator with known/computable size
+  #     abs_dir = File.expand_path("./baz") # => "/foo/bar/baz"
+  #     traverser = Enumerator.produce(abs_dir, size: -> { abs_dir.count("/") + 1 }) {
+  #       raise StopIteration if it == "/"
+  #       File.dirname(it)
+  #     }
+  #     traverser.size  # => 4
+  #
+  #     # Finite enumerator with unknown size
+  #     calendar = Enumerator.produce(Date.today, size: nil) {
+  #       it.monday? ? raise(StopIteration) : it + 1
+  #     }
+  #     calendar.size  # => nil
+  #
+  def self.produce: [T] () { (T? prev) -> T } -> Enumerator[T, bot]
+                  | [T] (T initial) { (T prev) -> T } -> Enumerator[T, bot]
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - Enumerator.product(*enums) -> enumerator
+  #   - Enumerator.product(*enums) { |elts| ... } -> enumerator
+  # -->
+  # Generates a new enumerator object that generates a Cartesian product of given
+  # enumerable objects.  This is equivalent to Enumerator::Product.new.
+  #
+  #     e = Enumerator.product(1..3, [4, 5])
+  #     e.to_a #=> [[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]
+  #     e.size #=> 6
+  #
+  # When a block is given, calls the block with each N-element array generated and
+  # returns `nil`.
+  #
+  def self.product: [E] (*_EachEntry[E]) -> Product[E]
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - enum.each { |elm| block }                    -> obj
+  #   - enum.each                                    -> enum
+  #   - enum.each(*appending_args) { |elm| block }   -> obj
+  #   - enum.each(*appending_args)                   -> an_enumerator
+  # -->
+  # Iterates over the block according to how this Enumerator was constructed. If
+  # no block and no arguments are given, returns self.
+  #
+  # ### Examples
+  #
+  #     "Hello, world!".scan(/\w+/)                     #=> ["Hello", "world"]
+  #     "Hello, world!".to_enum(:scan, /\w+/).to_a      #=> ["Hello", "world"]
+  #     "Hello, world!".to_enum(:scan).each(/\w+/).to_a #=> ["Hello", "world"]
+  #
+  #     obj = Object.new
+  #
+  #     def obj.each_arg(a, b=:b, *rest)
+  #       yield a
+  #       yield b
+  #       yield rest
+  #       :method_returned
+  #     end
+  #
+  #     enum = obj.to_enum :each_arg, :a, :x
+  #
+  #     enum.each.to_a                  #=> [:a, :x, []]
+  #     enum.each.equal?(enum)          #=> true
+  #     enum.each { |elm| elm }         #=> :method_returned
+  #
+  #     enum.each(:y, :z).to_a          #=> [:a, :x, [:y, :z]]
+  #     enum.each(:y, :z).equal?(enum)  #=> false
+  #     enum.each(:y, :z) { |elm| elm } #=> :method_returned
+  #
+  def each: () { (E arg0) -> untyped } -> R
+          | () -> self
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.feed obj   -> nil
+  # -->
+  # Sets the value to be returned by the next yield inside `e`.
+  #
+  # If the value is not set, the yield returns nil.
+  #
+  # This value is cleared after being yielded.
+  #
+  #     # Array#map passes the array's elements to "yield" and collects the
+  #     # results of "yield" as an array.
+  #     # Following example shows that "next" returns the passed elements and
+  #     # values passed to "feed" are collected as an array which can be
+  #     # obtained by StopIteration#result.
+  #     e = [1,2,3].map
+  #     p e.next           #=> 1
+  #     e.feed "a"
+  #     p e.next           #=> 2
+  #     e.feed "b"
+  #     p e.next           #=> 3
+  #     e.feed "c"
+  #     begin
+  #       e.next
+  #     rescue StopIteration
+  #       p $!.result      #=> ["a", "b", "c"]
+  #     end
+  #
+  #     o = Object.new
+  #     def o.each
+  #       x = yield         # (2) blocks
+  #       p x               # (5) => "foo"
+  #       x = yield         # (6) blocks
+  #       p x               # (8) => nil
+  #       x = yield         # (9) blocks
+  #       p x               # not reached w/o another e.next
+  #     end
+  #
+  #     e = o.to_enum
+  #     e.next              # (1)
+  #     e.feed "foo"        # (3)
+  #     e.next              # (4)
+  #     e.next              # (7)
+  #                         # (10)
+  #
+  def feed: (E arg0) -> NilClass
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - Enumerator.new(size = nil) { |yielder| ... }
+  # -->
+  # Creates a new Enumerator object, which can be used as an Enumerable.
+  #
+  # Iteration is defined by the given block, in which a "yielder" object, given as
+  # block parameter, can be used to yield a value by calling the `yield` method
+  # (aliased as <code><<</code>):
+  #
+  #     fib = Enumerator.new do |y|
+  #       a = b = 1
+  #       loop do
+  #         y << a
+  #         a, b = b, a + b
+  #       end
+  #     end
+  #
+  #     fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+  #
+  # The optional parameter can be used to specify how to calculate the size in a
+  # lazy fashion (see Enumerator#size). It can either be a value or a callable
+  # object.
+  #
+  def initialize: (?Integer arg0) { (Enumerator::Yielder arg0) -> R } -> void
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.inspect  -> string
+  # -->
+  # Creates a printable version of *e*.
+  #
+  def inspect: () -> String
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.next   -> object
+  # -->
+  # Returns the next object in the enumerator, and move the internal position
+  # forward.  When the position reached at the end, StopIteration is raised.
+  #
+  # ### Example
+  #
+  #     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
+  #
+  # See class-level notes about external iterators.
+  #
+  def next: () -> E
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.next_values   -> array
+  # -->
+  # Returns the next object as an array in the enumerator, and move the internal
+  # position forward.  When the position reached at the end, StopIteration is
+  # raised.
+  #
+  # See class-level notes about external iterators.
+  #
+  # This method can be used to distinguish `yield` and `yield nil`.
+  #
+  # ### Example
+  #
+  #     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]
+  #
+  def next_values: () -> ::Array[E]
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.peek   -> object
+  # -->
+  # Returns the next object in the enumerator, but doesn't move the internal
+  # position forward.  If the position is already at the end, StopIteration is
+  # raised.
+  #
+  # See class-level notes about external iterators.
+  #
+  # ### Example
+  #
+  #     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: () -> E
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.peek_values   -> array
+  # -->
+  # Returns the next object as an array, similar to Enumerator#next_values, but
+  # doesn't move the internal position forward.  If the position is already at the
+  # end, StopIteration is raised.
+  #
+  # See class-level notes about external iterators.
+  #
+  # ### Example
+  #
+  #     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[E]
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.rewind   -> e
+  # -->
+  # Rewinds the enumeration sequence to the beginning.
+  #
+  # If the enclosed object responds to a "rewind" method, it is called.
+  #
+  def rewind: () -> self
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.size          -> int, Float::INFINITY or nil
+  # -->
+  # Returns the size of the enumerator, or `nil` if it can't be calculated lazily.
+  #
+  #     (1..100).to_a.permutation(4).size # => 94109400
+  #     loop.size # => Float::INFINITY
+  #     (1..100).drop_while.size # => nil
+  #
+  # Note that enumerator size might be inaccurate, and should be rather treated as
+  # a hint. For example, there is no check that the size provided to ::new is
+  # accurate:
+  #
+  #     e = Enumerator.new(5) { |y| 2.times { y << it} }
+  #     e.size # => 5
+  #     e.to_a.size # => 2
+  #
+  # Another example is an enumerator created by ::produce without a `size`
+  # argument. Such enumerators return `Infinity` for size, but this is inaccurate
+  # if the passed block raises StopIteration:
+  #
+  #     e = Enumerator.produce(1) { it + 1 }
+  #     e.size # => Infinity
+  #
+  #     e = Enumerator.produce(1) { it > 3 ? raise(StopIteration) : it + 1 }
+  #     e.size # => Infinity
+  #     e.to_a.size # => 4
+  #
+  def size: () -> (Integer | Float)?
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e + enum -> enumerator
+  # -->
+  # Returns an enumerator object generated from this enumerator and a given
+  # enumerable.
+  #
+  #     e = (1..3).each + [4, 5]
+  #     e.to_a #=> [1, 2, 3, 4, 5]
+  #
+  def +: [Elem2] (::_Each[Elem2]) -> ::Enumerator::Chain[E | Elem2]
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - e.with_index(offset = 0) {|(*args), idx| ... }
+  #   - e.with_index(offset = 0)
+  # -->
+  # Iterates the given block for each element with an index, which starts from
+  # `offset`.  If no block is given, returns a new Enumerator that includes the
+  # index, starting from `offset`
+  #
+  # `offset`
+  # :   the starting index to use
+  #
+  def with_index: (?Integer offset) { (E arg0, Integer arg1) -> untyped } -> R
+                | (?Integer offset) -> ::Enumerator[[ E, Integer ], R]
+
+  # <!-- rdoc-file=enumerator.c -->
+  # Iterates the given block for each element with an arbitrary object, `obj`, and
+  # returns `obj`
+  #
+  # If no block is given, returns a new Enumerator.
+  #
+  # ### Example
+  #
+  #     to_three = Enumerator.new do |y|
+  #       3.times do |x|
+  #         y << x
+  #       end
+  #     end
+  #
+  #     to_three_with_string = to_three.with_object("foo")
+  #     to_three_with_string.each do |x,string|
+  #       puts "#{string}: #{x}"
+  #     end
+  #
+  #     # => foo: 0
+  #     # => foo: 1
+  #     # => foo: 2
+  #
+  def with_object: [U] (U obj) { (E, U obj) -> untyped } -> U
+                 | [U] (U obj) -> ::Enumerator[[ E, U ], U]
+end
+
+# <!-- rdoc-file=enumerator.c -->
+# Generator
+#
+class Enumerator::Generator[out E] < Object
+  include Enumerable[E]
+
+  def each: () { (E) -> void } -> void
+end
+
+# <!-- rdoc-file=enumerator.c -->
+# Enumerator::Lazy is a special type of Enumerator, that allows constructing
+# chains of operations without evaluating them immediately, and evaluating
+# values on as-needed basis. In order to do so it redefines most of Enumerable
+# methods so that they just construct another lazy enumerator.
+#
+# Enumerator::Lazy can be constructed from any Enumerable with the
+# Enumerable#lazy method.
+#
+#     lazy = (1..Float::INFINITY).lazy.select(&:odd?).drop(10).take_while { |i| i < 30 }
+#     # => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 1..Infinity>:select>:drop(10)>:take_while>
+#
+# The real enumeration is performed when any non-redefined Enumerable method is
+# called, like Enumerable#first or Enumerable#to_a (the latter is aliased as
+# #force for more semantic code):
+#
+#     lazy.first(2)
+#     #=> [21, 23]
+#
+#     lazy.force
+#     #=> [21, 23, 25, 27, 29]
+#
+# Note that most Enumerable methods that could be called with or without a
+# block, on Enumerator::Lazy will always require a block:
+#
+#     [1, 2, 3].map       #=> #<Enumerator: [1, 2, 3]:map>
+#     [1, 2, 3].lazy.map  # ArgumentError: tried to call lazy map without a block
+#
+# This class allows idiomatic calculations on long or infinite sequences, as
+# well as chaining of calculations without constructing intermediate arrays.
+#
+# Example for working with a slowly calculated sequence:
+#
+#     require 'open-uri'
+#
+#     # This will fetch all URLs before selecting
+#     # necessary data
+#     URLS.map { |u| JSON.parse(URI.open(u).read) }
+#       .select { |data| data.key?('stats') }
+#       .first(5)
+#
+#     # This will fetch URLs one-by-one, only till
+#     # there is enough data to satisfy the condition
+#     URLS.lazy.map { |u| JSON.parse(URI.open(u).read) }
+#       .select { |data| data.key?('stats') }
+#       .first(5)
+#
+# Ending a chain with ".eager" generates a non-lazy enumerator, which is
+# suitable for returning or passing to another method that expects a normal
+# enumerator.
+#
+#     def active_items
+#       groups
+#         .lazy
+#         .flat_map(&:items)
+#         .reject(&:disabled)
+#         .eager
+#     end
+#
+#     # This works lazily; if a checked item is found, it stops
+#     # iteration and does not look into remaining groups.
+#     first_checked = active_items.find(&:checked)
+#
+#     # This returns an array of items like a normal enumerator does.
+#     all_checked = active_items.select(&:checked)
+#
+class Enumerator::Lazy[out E, out R = void] < Enumerator[E, R]
+  # <!-- rdoc-file=enumerator.c -->
+  # Expands `lazy` enumerator to an array. See Enumerable#to_a.
+  #
+  alias force to_a
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - lazy.compact                  -> lazy_enumerator
+  # -->
+  # Like Enumerable#compact, but chains operation to be lazy-evaluated.
+  #
+  def compact: () -> Enumerator::Lazy[E, R]
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - lzy.eager -> enum
+  # -->
+  # Returns a non-lazy Enumerator converted from the lazy enumerator.
+  #
+  def eager: () -> ::Enumerator[E, R]
+end
+
+# <!-- rdoc-file=enumerator.c -->
+# Yielder
+#
+class Enumerator::Yielder < Object
+  def <<: (untyped arg0) -> void
+
+  def yield: (*untyped arg0) -> void
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - to_proc()
+  # -->
+  # Returns a Proc object that takes arguments and yields them.
+  #
+  # This method is implemented so that a Yielder object can be directly passed to
+  # another method as a block argument.
+  #
+  #     enum = Enumerator.new { |y|
+  #       Dir.glob("*.rb") { |file|
+  #         File.open(file) { |f| f.each_line(&y) }
+  #       }
+  #     }
+  #
+  def to_proc: () -> Proc
+end
+
+# <!-- rdoc-file=enumerator.c -->
+# Enumerator::Chain is a subclass of Enumerator, which represents a chain of
+# enumerables that works as a single enumerator.
+#
+# This type of objects can be created by Enumerable#chain and Enumerator#+.
+#
+class Enumerator::Chain[out E] < Enumerator[E, void]
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - Enumerator::Chain.new(*enums) -> enum
+  # -->
+  # Generates a new enumerator object that iterates over the elements of given
+  # enumerable objects in sequence.
+  #
+  #     e = Enumerator::Chain.new(1..3, [4, 5])
+  #     e.to_a #=> [1, 2, 3, 4, 5]
+  #     e.size #=> 5
+  #
+  def initialize: (*_Each[E] enums) -> void
+
+  # <!--
+  #   rdoc-file=enumerator.c
+  #   - obj.each(*args) { |...| ... } -> obj
+  #   - obj.each(*args) -> enumerator
+  # -->
+  # Iterates over the elements of the first enumerable by calling the "each"
+  # method on it with the given arguments, then proceeds to the following
+  # enumerables in sequence until all of the enumerables are exhausted.
+  #
+  # If no block is given, returns an enumerator.
+  #
+  def each: () { (E) -> void } -> self
+          | () -> Enumerator[E, self]
+end

data/core/env.rbs

@@ -0,0 +1,6 @@
+# <!-- rdoc-file=hash.c -->
+# `ENV` is a Hash-like accessor for environment variables.
+#
+# See ENV (the class) for more details.
+#
+ENV: RBS::Unnamed::ENVClass