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 : enumerable.rbs

# 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]: _Each[Elem]
  # 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) -> boolish } -> 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) -> boolish } -> bool

def collect: [U] () { (Elem arg0) -> U } -> ::Array[U]
             | () -> ::Enumerator[Elem, ::Array[untyped]]

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) -> Integer
           | () { (Elem) -> boolish } -> Integer

def cycle: (?Integer n) { (Elem arg0) -> untyped } -> NilClass
           | (?Integer n) -> ::Enumerator[Elem, NilClass]

def detect: (?Proc ifnone) { (Elem) -> boolish } -> Elem?
            | (?Proc ifnone) -> ::Enumerator[Elem, Elem?]

def drop: (Integer n) -> ::Array[Elem]

def drop_while: () { (Elem) -> boolish } -> ::Array[Elem]
                | () -> ::Enumerator[Elem, ::Array[Elem]]

def each_cons: (Integer n) { (::Array[Elem] arg0) -> untyped } -> NilClass
               | (Integer n) -> ::Enumerator[::Array[Elem], NilClass]

def each_with_index: () { (Elem arg0, Integer arg1) -> untyped } -> void
                     | () -> ::Enumerator[[ Elem, Integer ], void]

def each_with_object: [U] (U arg0) { (Elem arg0, untyped arg1) -> untyped } -> U
                      | [U] (U arg0) -> ::Enumerator[[ Elem, U ], U]

# 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) -> boolish } -> ::Array[Elem]
              | () -> ::Enumerator[Elem, ::Array[Elem]]

alias select find_all
  alias filter find_all

def find_index: (?untyped value) -> Integer?
                | () { (Elem) -> boolish } -> Integer?
                | () -> ::Enumerator[Elem, Integer?]

# 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, ::Array[Elem]]

def `include?`: (untyped arg0) -> bool

def inject: (untyped init, Symbol method) -> untyped
            | (Symbol method) -> untyped
            | [A] (A initial) { (A, Elem) -> A } -> A
            | () { (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, Elem?]
            | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
            | (Integer arg0) -> ::Enumerator[Elem, ::Array[Elem]]
            | (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, Elem?]
            | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
            | (Integer arg0) -> ::Enumerator[Elem, ::Array[Elem]]
            | (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]) } -> [ Elem?, Elem? ]

# 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) -> boolish } -> 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) -> boolish } -> bool

def partition: () { (Elem) -> boolish } -> [ ::Array[Elem], ::Array[Elem] ]
               | () -> ::Enumerator[Elem, [ ::Array[Elem], ::Array[Elem] ]]

def reject: () { (Elem) -> boolish } -> ::Array[Elem]
            | () -> ::Enumerator[Elem, ::Array[Elem]]

def reverse_each: () { (Elem arg0) -> untyped } -> void
                  | () -> ::Enumerator[Elem, void]

# 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, ::Array[Elem]]

def take: (Integer n) -> ::Array[Elem]?

def take_while: () { (Elem) -> boolish } -> ::Array[Elem]
                | () -> ::Enumerator[Elem, ::Array[Elem]]

# 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]
          | [T, U] () { (Elem) -> [T, U] } -> ::Hash[T, U]

def each_slice: (Integer n) { (::Array[Elem]) -> untyped } -> NilClass
                | (Integer n) -> ::Enumerator[::Array[Elem], NilClass]

interface _NotFound[T]
    def call: () -> T
  end

def find: () { (Elem) -> boolish } -> Elem?
          | () -> ::Enumerator[Elem, Elem?]
          | [T] (_NotFound[T] ifnone) { (Elem) -> boolish } -> (Elem | T)
          | [T] (_NotFound[T] ifnone) -> ::Enumerator[Elem, Elem | T]

def flat_map: [U] () { (Elem) -> (Array[U] | U) } -> Array[U]
              | () -> ::Enumerator[Elem, Array[untyped]]

def map: [U] () { (Elem arg0) -> U } -> ::Array[U]
         | () -> ::Enumerator[Elem, ::Array[untyped]]

def member?: (untyped arg0) -> bool

alias reduce inject

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

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 elem) -> (nil | false | U) } -> ::Array[U]
                | () -> ::Enumerator[Elem, ::Array[untyped]]

def chain: (*self enumerables) -> ::Enumerator::Chain[Elem]

def tally: () -> ::Hash[Elem, Integer]

def each_entry: () -> ::Enumerator[Elem, self]
                | () { (Elem arg0) -> untyped } -> self

# variadic type parameter is not supported yet
  # https://github.com/ruby/rbs/issues/21
  def zip: [Elem2] (::Enumerable[Elem2] enum) -> ::Array[[Elem, Elem2 | nil]]
         | [U, Elem2] (::Enumerable[Elem2]) { ([Elem, Elem2 | nil]) -> U } -> nil

def chunk: [U] () { (Elem elt) -> U } -> ::Enumerator[[U, Array[Elem]], void]
           | () -> ::Enumerator[Elem, Enumerator[untyped, untyped]]

def chunk_while: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem], void]

def slice_when: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem], void]

def slice_after: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
                 | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem], void]

def slice_before: (untyped pattern) -> ::Enumerator[::Array[Elem], void]
                  | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem], void]
end

${this.title}

Code Editor : enumerable.rbs