Gecko [ gandhischool.edu.np ]

Name	Size	Permission
array.rbs	72.62 KB	-rw-r--r--
basic_object.rbs	9.56 KB	-rw-r--r--
binding.rbs	5.31 KB	-rw-r--r--
builtin.rbs	1.36 KB	-rw-r--r--
class.rbs	4.43 KB	-rw-r--r--
comparable.rbs	4.07 KB	-rw-r--r--
complex.rbs	10.87 KB	-rw-r--r--
constants.rbs	434 B	-rw-r--r--
deprecated.rbs	54 B	-rw-r--r--
dir.rbs	13.67 KB	-rw-r--r--
encoding.rbs	11.92 KB	-rw-r--r--
enumerable.rbs	16.38 KB	-rw-r--r--
enumerator.rbs	6.69 KB	-rw-r--r--
errno.rbs	12.63 KB	-rw-r--r--
errors.rbs	14.09 KB	-rw-r--r--
exception.rbs	6.35 KB	-rw-r--r--
false_class.rbs	1.13 KB	-rw-r--r--
fiber.rbs	1.96 KB	-rw-r--r--
fiber_error.rbs	396 B	-rw-r--r--
file.rbs	39.24 KB	-rw-r--r--
file_test.rbs	1.73 KB	-rw-r--r--
float.rbs	20.24 KB	-rw-r--r--
gc.rbs	7.43 KB	-rw-r--r--
hash.rbs	34.02 KB	-rw-r--r--
integer.rbs	20.19 KB	-rw-r--r--
io.rbs	28.26 KB	-rw-r--r--
kernel.rbs	16.7 KB	-rw-r--r--
marshal.rbs	5.6 KB	-rw-r--r--
match_data.rbs	8.84 KB	-rw-r--r--
math.rbs	9.84 KB	-rw-r--r--
method.rbs	5.13 KB	-rw-r--r--
module.rbs	37.41 KB	-rw-r--r--
nil_class.rbs	1.73 KB	-rw-r--r--
numeric.rbs	11.72 KB	-rw-r--r--
object.rbs	26.36 KB	-rw-r--r--
object_space.rbs	3.41 KB	-rw-r--r--
proc.rbs	12.6 KB	-rw-r--r--
process.rbs	40.72 KB	-rw-r--r--
random.rbs	9.67 KB	-rw-r--r--
range.rbs	6.58 KB	-rw-r--r--
rational.rbs	12.72 KB	-rw-r--r--
rb_config.rbs	1.66 KB	-rw-r--r--
regexp.rbs	40.9 KB	-rw-r--r--
ruby_vm.rbs	384 B	-rw-r--r--
signal.rbs	1.81 KB	-rw-r--r--
string.rbs	77.2 KB	-rw-r--r--
string_io.rbs	8.02 KB	-rw-r--r--
struct.rbs	1.23 KB	-rw-r--r--
symbol.rbs	6.96 KB	-rw-r--r--
thread.rbs	34.03 KB	-rw-r--r--
thread_group.rbs	730 B	-rw-r--r--
time.rbs	40.94 KB	-rw-r--r--
trace_point.rbs	7.45 KB	-rw-r--r--
true_class.rbs	1.19 KB	-rw-r--r--
unbound_method.rbs	5.22 KB	-rw-r--r--
warning.rbs	835 B	-rw-r--r--

Code Editor : enumerator.rbs

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

class Enumerator::Generator[out Elem] < Object
  include Enumerable[Elem]
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]
end

${this.title}

Code Editor : enumerator.rbs