Gecko [ beriskala.com ]

Name	Size	Permission	Date
array.rbs	72.72 KB	-rw-r--r--	2024-06-26 17:25
basic_object.rbs	9.61 KB	-rw-r--r--	2024-06-26 17:25
binding.rbs	5.31 KB	-rw-r--r--	2024-06-26 17:25
builtin.rbs	1.36 KB	-rw-r--r--	2024-06-26 17:25
class.rbs	4.43 KB	-rw-r--r--	2024-06-26 17:25
comparable.rbs	4.07 KB	-rw-r--r--	2024-06-26 17:25
complex.rbs	10.87 KB	-rw-r--r--	2024-06-26 17:25
constants.rbs	434 B	-rw-r--r--	2024-06-26 17:25
deprecated.rbs	54 B	-rw-r--r--	2024-06-26 17:25
dir.rbs	13.67 KB	-rw-r--r--	2024-06-26 17:25
encoding.rbs	11.92 KB	-rw-r--r--	2024-06-26 17:25
enumerable.rbs	16.88 KB	-rw-r--r--	2024-06-26 17:25
enumerator.rbs	6.76 KB	-rw-r--r--	2024-06-26 17:25
errno.rbs	12.63 KB	-rw-r--r--	2024-06-26 17:25
errors.rbs	14.09 KB	-rw-r--r--	2024-06-26 17:25
exception.rbs	6.38 KB	-rw-r--r--	2024-06-26 17:25
false_class.rbs	1.13 KB	-rw-r--r--	2024-06-26 17:25
fiber.rbs	1.96 KB	-rw-r--r--	2024-06-26 17:25
fiber_error.rbs	396 B	-rw-r--r--	2024-06-26 17:25
file.rbs	39.26 KB	-rw-r--r--	2024-06-26 17:25
file_test.rbs	1.73 KB	-rw-r--r--	2024-06-26 17:25
float.rbs	20.23 KB	-rw-r--r--	2024-06-26 17:25
gc.rbs	7.43 KB	-rw-r--r--	2024-06-26 17:25
global_variables.rbs	5.54 KB	-rw-r--r--	2024-06-26 17:25
hash.rbs	34.25 KB	-rw-r--r--	2024-06-26 17:25
integer.rbs	20.19 KB	-rw-r--r--	2024-06-26 17:25
io.rbs	28.67 KB	-rw-r--r--	2024-06-26 17:25
kernel.rbs	18.63 KB	-rw-r--r--	2024-06-26 17:25
marshal.rbs	5.67 KB	-rw-r--r--	2024-06-26 17:25
match_data.rbs	8.84 KB	-rw-r--r--	2024-06-26 17:25
math.rbs	9.84 KB	-rw-r--r--	2024-06-26 17:25
method.rbs	5.13 KB	-rw-r--r--	2024-06-26 17:25
module.rbs	37.44 KB	-rw-r--r--	2024-06-26 17:25
nil_class.rbs	1.73 KB	-rw-r--r--	2024-06-26 17:25
numeric.rbs	11.97 KB	-rw-r--r--	2024-06-26 17:25
object.rbs	26.33 KB	-rw-r--r--	2024-06-26 17:25
object_space.rbs	3.41 KB	-rw-r--r--	2024-06-26 17:25
proc.rbs	12.6 KB	-rw-r--r--	2024-06-26 17:25
process.rbs	40.72 KB	-rw-r--r--	2024-06-26 17:25
random.rbs	9.76 KB	-rw-r--r--	2024-06-26 17:25
range.rbs	6.76 KB	-rw-r--r--	2024-06-26 17:25
rational.rbs	12.76 KB	-rw-r--r--	2024-06-26 17:25
rb_config.rbs	1.66 KB	-rw-r--r--	2024-06-26 17:25
regexp.rbs	40.9 KB	-rw-r--r--	2024-06-26 17:25
ruby_vm.rbs	384 B	-rw-r--r--	2024-06-26 17:25
signal.rbs	1.81 KB	-rw-r--r--	2024-06-26 17:25
string.rbs	77.23 KB	-rw-r--r--	2024-06-26 17:25
string_io.rbs	8.02 KB	-rw-r--r--	2024-06-26 17:25
struct.rbs	1.27 KB	-rw-r--r--	2024-06-26 17:25
symbol.rbs	6.99 KB	-rw-r--r--	2024-06-26 17:25
thread.rbs	34.52 KB	-rw-r--r--	2024-06-26 17:25
thread_group.rbs	730 B	-rw-r--r--	2024-06-26 17:25
time.rbs	40.98 KB	-rw-r--r--	2024-06-26 17:25
trace_point.rbs	7.45 KB	-rw-r--r--	2024-06-26 17:25
true_class.rbs	1.19 KB	-rw-r--r--	2024-06-26 17:25
unbound_method.rbs	5.22 KB	-rw-r--r--	2024-06-26 17:25
warning.rbs	835 B	-rw-r--r--	2024-06-26 17:25

Rename

# 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]

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 obj) { (Elem, U obj) -> untyped } -> U
                 | [U] (U obj) -> ::Enumerator[[ Elem, U ], U]
end

class Enumerator::Generator[out Elem] < Object
  include Enumerable[Elem]

def each: () { (Elem) -> void } -> void
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

def to_proc: () -> Proc
end

class Enumerator::Chain[out Elem] < Object
  include Enumerable[Elem]

def each: () { (Elem) -> void } -> void
end