steep 0.11.1 → 0.12.0

data/vendor/ruby-signature/stdlib/builtin/random.rbs

@@ -0,0 +1,93 @@
+# [Random](Random) provides an interface to Ruby's
+# pseudo-random number generator, or PRNG. The PRNG produces a
+# deterministic sequence of bits which approximate true randomness. The
+# sequence may be represented by integers, floats, or binary strings.
+# 
+# The generator may be initialized with either a system-generated or
+# user-supplied seed value by using
+# [::srand](Random#method-c-srand).
+# 
+# The class method [\#rand](Random#method-i-rand)
+# provides the base functionality of
+# [Kernel\#rand](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-rand)
+# along with better handling of floating point values. These are both
+# interfaces to Random::DEFAULT, the Ruby system PRNG.
+# 
+# [::new](Random#method-c-new) will create a new PRNG
+# with a state independent of Random::DEFAULT, allowing multiple
+# generators with different seed values or sequence positions to exist
+# simultaneously. [Random](Random) objects can be
+# marshaled, allowing sequences to be saved and resumed.
+# 
+# PRNGs are currently implemented as a modified Mersenne Twister with a
+# period of 2\*\*19937-1.
+class Random < Object
+  include Random::Formatter
+
+  def ==: (untyped arg0) -> bool
+
+  def bytes: (Integer size) -> String
+
+  def initialize: (?Integer seed) -> void
+
+  def rand: () -> Float
+          | (Integer | ::Range[Integer] max) -> Integer
+          | (Float | ::Range[Float] max) -> Float
+
+  # Returns the seed value used to initialize the generator. This may be
+  # used to initialize another generator with the same state at a later
+  # time, causing it to produce the same sequence of numbers.
+  # 
+  # ```ruby
+  # prng1 = Random.new(1234)
+  # prng1.seed       #=> 1234
+  # prng1.rand(100)  #=> 47
+  # 
+  # prng2 = Random.new(prng1.seed)
+  # prng2.rand(100)  #=> 47
+  # ```
+  def seed: () -> Integer
+
+  # Returns an arbitrary seed value. This is used by
+  # [::new](Random.downloaded.ruby_doc#method-c-new) when no seed value is
+  # specified as an argument.
+  # 
+  # ```ruby
+  # Random.new_seed  #=> 115032730400174366788466674494640623225
+  # ```
+  def self.new_seed: () -> Integer
+
+  def self.rand: (?Integer max) -> Numeric
+
+  def self.srand: (?Integer number) -> Numeric
+end
+
+Random::DEFAULT: Random
+
+module Random::Formatter
+  def base64: (?Integer? n) -> String
+
+  def hex: (?Integer? n) -> String
+
+  def rand: () -> Float
+          | (?Float? n) -> Float
+          | (?Integer? n) -> Integer
+          | (?Numeric? n) -> Numeric
+          | (?::Range[Float]? n) -> Float
+          | (?::Range[Integer]? n) -> Integer
+          | (?::Range[Numeric]? n) -> Numeric
+
+  def random_bytes: (?Integer? n) -> String
+
+  def random_number: () -> Float
+                   | (?Float? n) -> Float
+                   | (?Integer? n) -> Integer
+                   | (?Numeric? n) -> Numeric
+                   | (?::Range[Float]? n) -> Float
+                   | (?::Range[Integer]? n) -> Integer
+                   | (?::Range[Numeric]? n) -> Numeric
+
+  def urlsafe_base64: (?Integer? n, ?bool padding) -> String
+
+  def uuid: () -> String
+end

data/vendor/ruby-signature/stdlib/builtin/range.rbs

@@ -0,0 +1,226 @@
+# 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[Elem] < Object
+  include Enumerable[Elem, Range[Elem]]
+
+  def self.new: [U] (U from, U to, ?bool exclude_end) -> ::Range[U]
+
+  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
+
+  def bsearch: [U] () { (Elem arg0) -> bool } -> U?
+
+  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
+
+  # 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 _begin, Elem _end, ?bool 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 arg0, Elem arg1) -> Integer } -> Elem
+         | (?Integer n) -> ::Array[Elem]
+         | (?Integer n) { (Elem arg0, Elem arg1) -> 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 arg0, Elem arg1) -> Integer } -> Elem
+         | (?Integer n) -> ::Array[Elem]
+         | (?Integer n) { (Elem arg0, Elem arg1) -> 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

data/vendor/ruby-signature/stdlib/builtin/rational.rbs

@@ -0,0 +1,424 @@
+# A rational number can be represented as a pair of integer numbers: a/b (b>0),
+# where a is the numerator and b is the denominator. Integer a equals rational
+# a/1 mathematically.
+# 
+# In Ruby, you can create rational objects with the Kernel#Rational, to_r, or
+# rationalize methods or by suffixing `r` to a literal. The return values will
+# be irreducible fractions.
+# 
+#     Rational(1)      #=> (1/1)
+#     Rational(2, 3)   #=> (2/3)
+#     Rational(4, -6)  #=> (-2/3)
+#     3.to_r           #=> (3/1)
+#     2/3r             #=> (2/3)
+# 
+# You can also create rational objects from floating-point numbers or strings.
+# 
+#     Rational(0.3)    #=> (5404319552844595/18014398509481984)
+#     Rational('0.3')  #=> (3/10)
+#     Rational('2/3')  #=> (2/3)
+# 
+#     0.3.to_r         #=> (5404319552844595/18014398509481984)
+#     '0.3'.to_r       #=> (3/10)
+#     '2/3'.to_r       #=> (2/3)
+#     0.3.rationalize  #=> (3/10)
+# 
+# A rational object is an exact number, which helps you to write programs
+# without any rounding errors.
+# 
+#     10.times.inject(0) {|t| t + 0.1 }              #=> 0.9999999999999999
+#     10.times.inject(0) {|t| t + Rational('0.1') }  #=> (1/1)
+# 
+# However, when an expression includes an inexact component (numerical value or
+# operation), it will produce an inexact result.
+# 
+#     Rational(10) / 3   #=> (10/3)
+#     Rational(10) / 3.0 #=> 3.3333333333333335
+# 
+#     Rational(-8) ** Rational(1, 3)
+#                        #=> (1.0000000000000002+1.7320508075688772i)
+# 
+class Rational < Numeric
+  public
+
+  def %: (Integer) -> Rational
+       | (Float) -> Float
+       | (Rational) -> Rational
+       | (Numeric) -> Numeric
+
+  # Performs multiplication.
+  # 
+  #     Rational(2, 3)  * Rational(2, 3)   #=> (4/9)
+  #     Rational(900)   * Rational(1)      #=> (900/1)
+  #     Rational(-2, 9) * Rational(-9, 2)  #=> (1/1)
+  #     Rational(9, 8)  * 4                #=> (9/2)
+  #     Rational(20, 9) * 9.8              #=> 21.77777777777778
+  # 
+  def *: (Float) -> Float
+       | (Complex) -> Complex
+       | (Numeric) -> Numeric
+
+  # Performs exponentiation.
+  # 
+  #     Rational(2)    ** Rational(3)     #=> (8/1)
+  #     Rational(10)   ** -2              #=> (1/100)
+  #     Rational(10)   ** -2.0            #=> 0.01
+  #     Rational(-4)   ** Rational(1, 2)  #=> (0.0+2.0i)
+  #     Rational(1, 2) ** 0               #=> (1/1)
+  #     Rational(1, 2) ** 0.0             #=> 1.0
+  # 
+  def **: (Complex) -> Complex
+        | (Numeric) -> Numeric
+
+  # Performs addition.
+  # 
+  #     Rational(2, 3)  + Rational(2, 3)   #=> (4/3)
+  #     Rational(900)   + Rational(1)      #=> (901/1)
+  #     Rational(-2, 9) + Rational(-9, 2)  #=> (-85/18)
+  #     Rational(9, 8)  + 4                #=> (41/8)
+  #     Rational(20, 9) + 9.8              #=> 12.022222222222222
+  # 
+  def +: (Float) -> Float
+       | (Complex) -> Complex
+       | (Numeric) -> Rational
+
+  def +@: () -> Rational
+
+  # Performs subtraction.
+  # 
+  #     Rational(2, 3)  - Rational(2, 3)   #=> (0/1)
+  #     Rational(900)   - Rational(1)      #=> (899/1)
+  #     Rational(-2, 9) - Rational(-9, 2)  #=> (77/18)
+  #     Rational(9, 8)  - 4                #=> (-23/8)
+  #     Rational(20, 9) - 9.8              #=> -7.577777777777778
+  # 
+  def -: (Float) -> Float
+       | (Complex) -> Complex
+       | (Numeric) -> Rational
+
+  # Negates `rat`.
+  # 
+  def -@: () -> Rational
+
+  # Performs division.
+  # 
+  #     Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
+  #     Rational(900)   / Rational(1)      #=> (900/1)
+  #     Rational(-2, 9) / Rational(-9, 2)  #=> (4/81)
+  #     Rational(9, 8)  / 4                #=> (9/32)
+  #     Rational(20, 9) / 9.8              #=> 0.22675736961451246
+  # 
+  def /: (Float) -> Float
+       | (Complex) -> Complex
+       | (Numeric) -> Rational
+
+  # Returns -1, 0, or +1 depending on whether `rational` is less than, equal to,
+  # or greater than `numeric`.
+  # 
+  # `nil` is returned if the two values are incomparable.
+  # 
+  #     Rational(2, 3) <=> Rational(2, 3)  #=> 0
+  #     Rational(5)    <=> 5               #=> 0
+  #     Rational(2, 3) <=> Rational(1, 3)  #=> 1
+  #     Rational(1, 3) <=> 1               #=> -1
+  #     Rational(1, 3) <=> 0.3             #=> 1
+  # 
+  #     Rational(1, 3) <=> "0.3"           #=> nil
+  # 
+  def <=>: (Numeric) -> Integer?
+
+  # Returns `true` if `rat` equals `object` numerically.
+  # 
+  #     Rational(2, 3)  == Rational(2, 3)   #=> true
+  #     Rational(5)     == 5                #=> true
+  #     Rational(0)     == 0.0              #=> true
+  #     Rational('1/3') == 0.33             #=> false
+  #     Rational('1/2') == '1/2'            #=> false
+  # 
+  def ==: (untyped) -> bool
+
+  # Returns the absolute value of `rat`.
+  # 
+  #     (1/2r).abs    #=> (1/2)
+  #     (-1/2r).abs   #=> (1/2)
+  # 
+  # Rational#magnitude is an alias for Rational#abs.
+  # 
+  def abs: () -> Rational
+
+  def abs2: () -> Rational
+
+  def angle: () -> (Integer | Float)
+
+  alias arg angle
+
+  # Returns the smallest number greater than or equal to `rat` with a precision of
+  # `ndigits` decimal digits (default: 0).
+  # 
+  # When the precision is negative, the returned value is an integer with at least
+  # `ndigits.abs` trailing zeros.
+  # 
+  # Returns a rational when `ndigits` is positive, otherwise returns an integer.
+  # 
+  #     Rational(3).ceil      #=> 3
+  #     Rational(2, 3).ceil   #=> 1
+  #     Rational(-3, 2).ceil  #=> -1
+  # 
+  #       #    decimal      -  1  2  3 . 4  5  6
+  #       #                   ^  ^  ^  ^   ^  ^
+  #       #   precision      -3 -2 -1  0  +1 +2
+  # 
+  #     Rational('-123.456').ceil(+1).to_f  #=> -123.4
+  #     Rational('-123.456').ceil(-1)       #=> -120
+  # 
+  def ceil: () -> Integer
+          | (Integer digits) -> (Integer | Rational)
+
+  def clone: (?freeze: bool) -> self
+
+  def coerce: (Numeric) -> [Numeric, Numeric]
+
+  def conj: () -> Rational
+
+  def conjugate: () -> Rational
+
+  # Returns the denominator (always positive).
+  # 
+  #     Rational(7).denominator             #=> 1
+  #     Rational(7, 1).denominator          #=> 1
+  #     Rational(9, -4).denominator         #=> 4
+  #     Rational(-2, -10).denominator       #=> 5
+  # 
+  def denominator: () -> Integer
+
+  def div: (Numeric) -> Integer
+
+  def divmod: (Numeric) -> [Numeric, Numeric]
+
+  def dup: () -> self
+
+  def eql?: (untyped) -> bool
+
+  # Performs division and returns the value as a Float.
+  # 
+  #     Rational(2, 3).fdiv(1)       #=> 0.6666666666666666
+  #     Rational(2, 3).fdiv(0.5)     #=> 1.3333333333333333
+  #     Rational(2).fdiv(3)          #=> 0.6666666666666666
+  # 
+  def fdiv: (Numeric) -> Float
+
+  def finite?: () -> bool
+
+  # Returns the largest number less than or equal to `rat` with a precision of
+  # `ndigits` decimal digits (default: 0).
+  # 
+  # When the precision is negative, the returned value is an integer with at least
+  # `ndigits.abs` trailing zeros.
+  # 
+  # Returns a rational when `ndigits` is positive, otherwise returns an integer.
+  # 
+  #     Rational(3).floor      #=> 3
+  #     Rational(2, 3).floor   #=> 0
+  #     Rational(-3, 2).floor  #=> -2
+  # 
+  #       #    decimal      -  1  2  3 . 4  5  6
+  #       #                   ^  ^  ^  ^   ^  ^
+  #       #   precision      -3 -2 -1  0  +1 +2
+  # 
+  #     Rational('-123.456').floor(+1).to_f  #=> -123.5
+  #     Rational('-123.456').floor(-1)       #=> -130
+  # 
+  def floor: () -> Integer
+           | (Integer digits) -> (Integer | Rational)
+
+  def hash: () -> Integer
+
+  def i: () -> Complex
+
+  def imag: () -> Integer
+
+  def imaginary: () -> Integer
+
+  def infinite?: () -> Integer?
+
+  # Returns the value as a string for inspection.
+  # 
+  #     Rational(2).inspect      #=> "(2/1)"
+  #     Rational(-8, 6).inspect  #=> "(-4/3)"
+  #     Rational('1/2').inspect  #=> "(1/2)"
+  # 
+  def inspect: () -> String
+
+  def integer?: () -> bool
+
+  # Returns the absolute value of `rat`.
+  # 
+  #     (1/2r).abs    #=> (1/2)
+  #     (-1/2r).abs   #=> (1/2)
+  # 
+  # Rational#magnitude is an alias for Rational#abs.
+  # 
+  alias magnitude abs
+
+  def modulo: (Float) -> Float
+            | (Numeric) -> Rational
+
+  # Returns `true` if `rat` is less than 0.
+  # 
+  def negative?: () -> bool
+
+  def nonzero?: () -> self?
+
+  # Returns the numerator.
+  # 
+  #     Rational(7).numerator        #=> 7
+  #     Rational(7, 1).numerator     #=> 7
+  #     Rational(9, -4).numerator    #=> -9
+  #     Rational(-2, -10).numerator  #=> 1
+  # 
+  def numerator: () -> Integer
+
+  alias phase angle
+
+  def polar: () -> [ Rational, Integer | Float ]
+
+  # Returns `true` if `rat` is greater than 0.
+  # 
+  def positive?: () -> bool
+
+  # Performs division.
+  # 
+  #     Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
+  #     Rational(900)   / Rational(1)      #=> (900/1)
+  #     Rational(-2, 9) / Rational(-9, 2)  #=> (4/81)
+  #     Rational(9, 8)  / 4                #=> (9/32)
+  #     Rational(20, 9) / 9.8              #=> 0.22675736961451246
+  # 
+  def quo: (Float) -> Float
+         | (Complex) -> Complex
+         | (Numeric) -> Rational
+
+  # Returns a simpler approximation of the value if the optional argument `eps` is
+  # given (rat-|eps| <= result <= rat+|eps|), self otherwise.
+  # 
+  #     r = Rational(5033165, 16777216)
+  #     r.rationalize                    #=> (5033165/16777216)
+  #     r.rationalize(Rational('0.01'))  #=> (3/10)
+  #     r.rationalize(Rational('0.1'))   #=> (1/3)
+  # 
+  def rationalize: (?Numeric eps) -> Rational
+
+  def real: () -> Rational
+
+  def real?: () -> true
+
+  def rect: () -> [ Rational, Numeric ]
+
+  alias rectangular rect
+
+  def remainder: (Float) -> Float
+               | (Numeric) -> Rational
+
+  # Returns `rat` rounded to the nearest value with a precision of `ndigits`
+  # decimal digits (default: 0).
+  # 
+  # When the precision is negative, the returned value is an integer with at least
+  # `ndigits.abs` trailing zeros.
+  # 
+  # Returns a rational when `ndigits` is positive, otherwise returns an integer.
+  # 
+  #     Rational(3).round      #=> 3
+  #     Rational(2, 3).round   #=> 1
+  #     Rational(-3, 2).round  #=> -2
+  # 
+  #       #    decimal      -  1  2  3 . 4  5  6
+  #       #                   ^  ^  ^  ^   ^  ^
+  #       #   precision      -3 -2 -1  0  +1 +2
+  # 
+  #     Rational('-123.456').round(+1).to_f  #=> -123.5
+  #     Rational('-123.456').round(-1)       #=> -120
+  # 
+  # The optional `half` keyword argument is available similar to Float#round.
+  # 
+  #     Rational(25, 100).round(1, half: :up)    #=> (3/10)
+  #     Rational(25, 100).round(1, half: :down)  #=> (1/5)
+  #     Rational(25, 100).round(1, half: :even)  #=> (1/5)
+  #     Rational(35, 100).round(1, half: :up)    #=> (2/5)
+  #     Rational(35, 100).round(1, half: :down)  #=> (3/10)
+  #     Rational(35, 100).round(1, half: :even)  #=> (2/5)
+  #     Rational(-25, 100).round(1, half: :up)   #=> (-3/10)
+  #     Rational(-25, 100).round(1, half: :down) #=> (-1/5)
+  #     Rational(-25, 100).round(1, half: :even) #=> (-1/5)
+  # 
+  def round: (?half: :up | :down | :even) -> Integer
+           | (Integer digits, ?half: :up | :down | :even) -> (Integer | Rational)
+
+  def step: (?Numeric limit, ?Numeric step) { (Rational) -> void } -> self
+          | (?Numeric limit, ?Numeric step) -> Enumerator[Rational, self]
+          | (?by: Numeric, ?to: Numeric) { (Rational) -> void } -> self
+          | (?by: Numeric, ?to: Numeric) -> Enumerator[Rational, self]
+
+  def to_c: () -> Complex
+
+  # Returns the value as a Float.
+  # 
+  #     Rational(2).to_f      #=> 2.0
+  #     Rational(9, 4).to_f   #=> 2.25
+  #     Rational(-3, 4).to_f  #=> -0.75
+  #     Rational(20, 3).to_f  #=> 6.666666666666667
+  # 
+  def to_f: () -> Float
+
+  # Returns the truncated value as an integer.
+  # 
+  # Equivalent to Rational#truncate.
+  # 
+  #     Rational(2, 3).to_i    #=> 0
+  #     Rational(3).to_i       #=> 3
+  #     Rational(300.6).to_i   #=> 300
+  #     Rational(98, 71).to_i  #=> 1
+  #     Rational(-31, 2).to_i  #=> -15
+  # 
+  def to_i: () -> Integer
+
+  alias to_int to_i
+
+  # Returns self.
+  # 
+  #     Rational(2).to_r      #=> (2/1)
+  #     Rational(-8, 6).to_r  #=> (-4/3)
+  # 
+  def to_r: () -> Rational
+
+  # Returns the value as a string.
+  # 
+  #     Rational(2).to_s      #=> "2/1"
+  #     Rational(-8, 6).to_s  #=> "-4/3"
+  #     Rational('1/2').to_s  #=> "1/2"
+  # 
+  def to_s: () -> String
+
+  # Returns `rat` truncated (toward zero) to a precision of `ndigits` decimal
+  # digits (default: 0).
+  # 
+  # When the precision is negative, the returned value is an integer with at least
+  # `ndigits.abs` trailing zeros.
+  # 
+  # Returns a rational when `ndigits` is positive, otherwise returns an integer.
+  # 
+  #     Rational(3).truncate      #=> 3
+  #     Rational(2, 3).truncate   #=> 0
+  #     Rational(-3, 2).truncate  #=> -1
+  # 
+  #       #    decimal      -  1  2  3 . 4  5  6
+  #       #                   ^  ^  ^  ^   ^  ^
+  #       #   precision      -3 -2 -1  0  +1 +2
+  # 
+  #     Rational('-123.456').truncate(+1).to_f  #=> -123.4
+  #     Rational('-123.456').truncate(-1)       #=> -120
+  # 
+  def truncate: () -> Integer
+              | (Integer ndigits) -> (Integer | Rational)
+
+  def zero?: () -> bool
+end