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 `Range` represents an interval—a set of values with a beginning and an
# end. Ranges may be constructed using the *s* `..` *e* and *s* `...` *e*
# literals, or with [::new](Range#method-c-new).
# Ranges constructed using `..` run from the beginning to the end
# inclusively. Those created using `...` exclude the end value. When used
# as an iterator, ranges return each value in the sequence.
#
# ```ruby
# (-1..-5).to_a      #=> []
# (-5..-1).to_a      #=> [-5, -4, -3, -2, -1]
# ('a'..'e').to_a    #=> ["a", "b", "c", "d", "e"]
# ('a'...'e').to_a   #=> ["a", "b", "c", "d"]
# ```
#
#
# An “endless range” represents a semi-infinite range. Literal notation
# for an endless range is:
#
#     (1..)
#     # or similarly
#     (1...)
#
# Which is equivalent to
#
# ```ruby
# (1..nil)  # or similarly (1...nil)
# Range.new(1, nil) # or Range.new(1, nil, true)
# ```
#
# Endless ranges are useful, for example, for idiomatic slicing of arrays:
#
#     [1, 2, 3, 4, 5][2...]   # => [3, 4, 5]
#
# Some implementation details:
#
#   - `end` of endless range is `nil` ;
#
#   - `each` of endless range enumerates infinite sequence (may be useful
#     in combination with
#     [Enumerable\#take\_while](https://ruby-doc.org/core-2.6.3/Enumerable.html#method-i-take_while)
#     or similar methods);
#
#   - `(1..)` and `(1...)` are not equal, although technically
#     representing the same sequence.
#
#
# Ranges can be constructed using any objects that can be compared using
# the `<=>` operator. Methods that treat the range as a sequence (\#each
# and methods inherited from
# [Enumerable](https://ruby-doc.org/core-2.6.3/Enumerable.html) ) expect
# the begin object to implement a `succ` method to return the next object
# in sequence. The [step](Range#method-i-step) and
# [include?](Range#method-i-include-3F) methods
# require the begin object to implement `succ` or to be numeric.
#
# In the `Xs` class below both `<=>` and `succ` are implemented so `Xs`
# can be used to construct ranges. Note that the
# [Comparable](https://ruby-doc.org/core-2.6.3/Comparable.html) module is
# included so the `==` method is defined in terms of `<=>` .
#
# ```ruby
# class Xs                # represent a string of 'x's
#   include Comparable
#   attr :length
#   def initialize(n)
#     @length = n
#   end
#   def succ
#     Xs.new(@length + 1)
#   end
#   def <=>(other)
#     @length <=> other.length
#   end
#   def to_s
#     sprintf "%2d #{inspect}", @length
#   end
#   def inspect
#     'x' * @length
#   end
# end
# ```
#
# An example of using `Xs` to construct a range:
#
# ```ruby
# r = Xs.new(3)..Xs.new(6)   #=> xxx..xxxxxx
# r.to_a                     #=> [xxx, xxxx, xxxxx, xxxxxx]
# r.member?(Xs.new(5))       #=> true
# ```
class Range[out Elem] < Object
  include Enumerable[Elem]

def ==: (untyped obj) -> bool

def ===: (untyped obj) -> bool

# Returns the object that defines the beginning of the range.
  #
  # ```ruby
  # (1..10).begin   #=> 1
  # ```
  def begin: () -> Elem      # Begin-less ranges have type of Range[Integer?]

def bsearch: () -> ::Enumerator[Elem, Elem?]
             | () { (Elem) -> (true | false) } -> Elem?
             | () { (Elem) -> ::Integer } -> Elem?

def cover?: (untyped obj) -> bool

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

# Returns the object that defines the end of the range.
  #
  # ```ruby
  # (1..10).end    #=> 10
  # (1...10).end   #=> 10
  # ```
  def `end`: () -> Elem      # End-less ranges have type of Range[Integer?]

# Returns `true` if the range excludes its end value.
  #
  # ```ruby
  # (1..5).exclude_end?     #=> false
  # (1...5).exclude_end?    #=> true
  # ```
  def `exclude_end?`: () -> bool

# Returns the first object in the range, or an array of the first `n`
  # elements.
  #
  # ```ruby
  # (10..20).first     #=> 10
  # (10..20).first(3)  #=> [10, 11, 12]
  # ```
  def first: () -> Elem
           | (Integer n) -> ::Array[Elem]

# Compute a hash-code for this range. Two ranges with equal begin and end
  # points (using `eql?` ), and the same
  # [exclude\_end?](Range.downloaded.ruby_doc#method-i-exclude_end-3F) value
  # will generate the same hash-code.
  #
  # See also Object\#hash.
  def hash: () -> Integer

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

def initialize: (Elem from, Elem to, ?boolish exclude_end) -> void

# Convert this range object to a printable form (using `inspect` to
  # convert the begin and end objects).
  def inspect: () -> String

# Returns the last object in the range, or an array of the last `n`
  # elements.
  #
  # Note that with no arguments `last` will return the object that defines
  # the end of the range even if
  # [exclude\_end?](Range.downloaded.ruby_doc#method-i-exclude_end-3F) is
  # `true` .
  #
  # ```ruby
  # (10..20).last      #=> 20
  # (10...20).last     #=> 20
  # (10..20).last(3)   #=> [18, 19, 20]
  # (10...20).last(3)  #=> [17, 18, 19]
  # ```
  def last: () -> Elem
          | (Integer n) -> ::Array[Elem]

# Returns the maximum value in the range. Returns `nil` if the begin value
  # of the range larger than the end value. Returns `nil` if the begin value
  # of an exclusive range is equal to the end value.
  #
  # Can be given an optional block to override the default comparison method
  # `a <=> b` .
  #
  # ```ruby
  # (10..20).max    #=> 20
  # ```
  def max: () -> Elem
         | () { (Elem a, Elem b) -> Integer } -> Elem
         | (Integer n) -> ::Array[Elem]
         | (Integer n) { (Elem a, Elem b) -> Integer } -> ::Array[Elem]

# Returns the minimum value in the range. Returns `nil` if the begin value
  # of the range is larger than the end value. Returns `nil` if the begin
  # value of an exclusive range is equal to the end value.
  #
  # Can be given an optional block to override the default comparison method
  # `a <=> b` .
  #
  # ```ruby
  # (10..20).min    #=> 10
  # ```
  def min: () -> Elem
         | () { (Elem a, Elem b) -> Integer } -> Elem
         | (Integer n) -> ::Array[Elem]
         | (Integer n) { (Elem a, Elem b) -> Integer } -> ::Array[Elem]

# Returns the number of elements in the range. Both the begin and the end
  # of the [Range](Range.downloaded.ruby_doc) must be
  # [Numeric](https://ruby-doc.org/core-2.6.3/Numeric.html), otherwise nil
  # is returned.
  #
  # ```ruby
  # (10..20).size    #=> 11
  # ('a'..'z').size  #=> nil
  # (-Float::INFINITY..Float::INFINITY).size #=> Infinity
  # ```
  def size: () -> Integer?
          | () -> Float?

def step: (?Integer n) { (Elem arg0) -> untyped } -> self
          | (?Integer n) -> ::Enumerator[Elem, void]

# Convert this range object to a printable form (using
  # [to\_s](Range.downloaded.ruby_doc#method-i-to_s) to convert the begin
  # and end objects).
  def to_s: () -> String

def eql?: (untyped obj) -> bool

def member?: (untyped obj) -> bool
end