rbs 3.10.4 → 4.0.0

data/core/hash.rbs

@@ -8,7 +8,7 @@
 #
 # ### Hash Data Syntax
 #
-# The original syntax for a hash entry uses the "hash rocket," `=>`:
+# The original syntax for a hash entry uses the "hash rocket," <code>=></code>:
 #
 #     h = {:foo => 0, :bar => 1, :baz => 2}
 #     h # => {foo: 0, bar: 1, baz: 2}
@@ -165,7 +165,7 @@
 # #### `Hash` Key Equivalence
 #
 # Two objects are treated as the same hash key when their `hash` value is
-# identical and the two objects are `eql?` to each other.
+# identical and the two objects are <code>eql?</code> to each other.
 #
 # #### Modifying an Active `Hash` Key
 #
@@ -180,7 +180,7 @@
 #     h[a0] # => 0
 #     a0.hash # => 110002110
 #
-# Modifying array element `a0[0]` changes its hash value:
+# Modifying array element <code>a0[0]</code> changes its hash value:
 #
 #     a0[0] = :bam
 #     a0.hash # => 1069447059
@@ -208,17 +208,17 @@
 # #### User-Defined `Hash` Keys
 #
 # To be usable as a `Hash` key, objects must implement the methods `hash` and
-# `eql?`. Note: this requirement does not apply if the `Hash` uses
+# <code>eql?</code>. Note: this requirement does not apply if the `Hash` uses
 # #compare_by_identity since comparison will then rely on the keys' object id
-# instead of `hash` and `eql?`.
+# instead of `hash` and <code>eql?</code>.
 #
-# Object defines basic implementation for `hash` and `eq?` that makes each
-# object a distinct key. Typically, user-defined classes will want to override
-# these methods to provide meaningful behavior, or for example inherit Struct
-# that has useful definitions for these.
+# Object defines basic implementation for `hash` and <code>eq?</code> that makes
+# each object a distinct key. Typically, user-defined classes will want to
+# override these methods to provide meaningful behavior, or for example inherit
+# Struct that has useful definitions for these.
 #
-# A typical implementation of `hash` is based on the object's data while `eql?`
-# is usually aliased to the overridden `==` method:
+# A typical implementation of `hash` is based on the object's data while
+# <code>eql?</code> is usually aliased to the overridden <code>==</code> method:
 #
 #     class Book
 #       attr_reader :author, :title
@@ -263,7 +263,7 @@
 #
 # If you want `nil` returned for a not-found key, you can call:
 #
-# *   #[](key) (usually written as `#[key]`.
+# *   #[](key) (usually written as <code>#[key]</code>.
 # *   #assoc(key).
 # *   #dig(key, *identifiers).
 # *   #values_at(*keys).
@@ -524,10 +524,12 @@ class Hash[unchecked out K, unchecked out V] < Object
   # -->
   # If `object` is a hash, returns `object`.
   #
-  # Otherwise if `object` responds to `:to_hash`, calls `object.to_hash`; returns
-  # the result if it is a hash, or raises TypeError if not.
+  # Otherwise if `object` responds to <code>:to_hash</code>, calls
+  # <code>object.to_hash</code>; returns the result if it is a hash, or raises
+  # TypeError if not.
   #
-  # Otherwise if `object` does not respond to `:to_hash`, returns `nil`.
+  # Otherwise if `object` does not respond to <code>:to_hash</code>, returns
+  # `nil`.
   #
   def self.try_convert: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
                       | (untyped) -> (::Hash[untyped, untyped] | nil)
@@ -587,7 +589,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # *   `object` is a `Hash` object (or can be converted to one).
   # *   `self` and `object` have the same keys (regardless of order).
-  # *   For each key `key`, `self[key] == object[key]`.
+  # *   For each key `key`, <code>self[key] == object[key]</code>.
   #
   # Otherwise, returns `false`.
   #
@@ -716,7 +718,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   # otherwise.
   #
   # With argument `entry` and no block, returns `true` if for any key `key`
-  # `self.assoc(key) == entry`, `false` otherwise:
+  # <code>self.assoc(key) == entry</code>, `false` otherwise:
   #
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.assoc(:bar)     # => [:bar, 1]
@@ -1103,7 +1105,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # *   The given `object` is a `Hash` object.
   # *   `self` and `object` have the same keys (regardless of order).
-  # *   For each key `key`, `self[key].eql?(object[key])`.
+  # *   For each key `key`, <code>self[key].eql?(object[key])</code>.
   #
   # Otherwise, returns `false`.
   #
@@ -1232,7 +1234,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   # *   Each element whose value is not an array is unchanged. even if the value
   #     is an object that has instance method flatten (such as a hash).
   #
-  # Examples; note that entry `foo: {bar: 1, baz: 2}` is never flattened.
+  # Examples; note that entry <code>foo: {bar: 1, baz: 2}</code> is never
+  # flattened.
   #
   #     h = {foo: {bar: 1, baz: 2}, bat: [:bam, [:bap, [:bah]]]}
   #     h.flatten(1) # => [:foo, {:bar=>1, :baz=>2}, :bat, [:bam, [:bap, [:bah]]]]
@@ -1264,7 +1267,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Related: [Methods for Querying](rdoc-ref:Hash@Methods+for+Querying).
   #
-  def has_key?: (K arg0) -> bool
+  def has_key?: (_Key) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -1274,7 +1277,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Related: [Methods for Querying](rdoc-ref:Hash@Methods+for+Querying).
   #
-  def has_value?: (V arg0) -> bool
+  def has_value?: (top arg0) -> bool
 
   # <!--
   #   rdoc-file=hash.c
@@ -1475,8 +1478,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   # With no block given, for each successive entry `key`/`new_value` in each
   # successive `other_hash`:
   #
-  # *   If `key` is in `self`, sets `self[key] = new_value`, whose position is
-  #     unchanged:
+  # *   If `key` is in `self`, sets <code>self[key] = new_value</code>, whose
+  #     position is unchanged:
   #
   #         h0 = {foo: 0, bar: 1, baz: 2}
   #         h1 = {bar: 3, foo: -1}
@@ -1490,9 +1493,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   # With a block given, for each successive entry `key`/`new_value` in each
   # successive `other_hash`:
   #
-  # *   If `key` is in `self`, fetches `old_value` from `self[key]`, calls the
-  #     block with `key`, `old_value`, and `new_value`, and sets `self[key] =
-  #     new_value`, whose position is unchanged  :
+  # *   If `key` is in `self`, fetches `old_value` from <code>self[key]</code>,
+  #     calls the block with `key`, `old_value`, and `new_value`, and sets
+  #     <code>self[key] = new_value</code>, whose position is unchanged  :
   #
   #         season = {AB: 75, H: 20, HR: 3, SO: 17, W: 11, HBP: 3}
   #         today = {AB: 3, H: 1, W: 1}
@@ -1515,8 +1518,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #   rdoc-file=hash.c
   #   - rassoc(value) -> new_array or nil
   # -->
-  # Searches `self` for the first entry whose value is `==` to the given `value`;
-  # see [Entry Order](rdoc-ref:Hash@Entry+Order).
+  # Searches `self` for the first entry whose value is <code>==</code> to the
+  # given `value`; see [Entry Order](rdoc-ref:Hash@Entry+Order).
   #
   # If the entry is found, returns its key and value as a 2-element array; returns
   # `nil` if not found:
@@ -1796,9 +1799,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   # With a block given and no argument, `new_hash` has keys determined only by the
   # block.
   #
-  # For each key/value pair `old_key/value` in `self`, calls the block with
-  # `old_key`; the block's return value becomes `new_key`; sets `new_hash[new_key]
-  # = value`; a duplicate key overwrites:
+  # For each key/value pair <code>old_key/value</code> in `self`, calls the block
+  # with `old_key`; the block's return value becomes `new_key`; sets
+  # <code>new_hash[new_key] = value</code>; a duplicate key overwrites:
   #
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.transform_keys {|old_key| old_key.to_s }
@@ -1809,11 +1812,12 @@ class Hash[unchecked out K, unchecked out V] < Object
   # With argument `other_hash` given and no block, `new_hash` may have new keys
   # provided by `other_hash` and unchanged keys provided by `self`.
   #
-  # For each key/value pair `old_key/old_value` in `self`, looks for key `old_key`
-  # in `other_hash`:
+  # For each key/value pair <code>old_key/old_value</code> in `self`, looks for
+  # key `old_key` in `other_hash`:
   #
-  # *   If `old_key` is found, its value `other_hash[old_key]` is taken as
-  #     `new_key`; sets `new_hash[new_key] = value`; a duplicate key overwrites:
+  # *   If `old_key` is found, its value <code>other_hash[old_key]</code> is taken
+  #     as `new_key`; sets <code>new_hash[new_key] = value</code>; a duplicate key
+  #     overwrites:
   #
   #         h = {foo: 0, bar: 1, baz: 2}
   #         h.transform_keys(baz: :BAZ, bar: :BAR, foo: :FOO)
@@ -1821,8 +1825,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #         h.transform_keys(baz: :FOO, bar: :FOO, foo: :FOO)
   #         # => {FOO: 2}
   #
-  # *   If `old_key` is not found, sets `new_hash[old_key] = value`; a duplicate
-  #     key overwrites:
+  # *   If `old_key` is not found, sets <code>new_hash[old_key] = value</code>; a
+  #     duplicate key overwrites:
   #
   #         h = {foo: 0, bar: 1, baz: 2}
   #         h.transform_keys({})
@@ -1843,16 +1847,16 @@ class Hash[unchecked out K, unchecked out V] < Object
   # For each pair `old_key` and `value` in `self`:
   #
   # *   If `other_hash` has key `old_key` (with value `new_key`), does not call
-  #     the block for that key; sets `new_hash[new_key] = value`; a duplicate key
-  #     overwrites:
+  #     the block for that key; sets <code>new_hash[new_key] = value</code>; a
+  #     duplicate key overwrites:
   #
   #         h = {foo: 0, bar: 1, baz: 2}
   #         h.transform_keys(baz: :BAZ, bar: :BAR, foo: :FOO) {|key| fail 'Not called' }
   #         # => {FOO: 0, BAR: 1, BAZ: 2}
   #
   # *   If `other_hash` does not have key `old_key`, calls the block with
-  #     `old_key` and takes its return value as `new_key`; sets `new_hash[new_key]
-  #     = value`; a duplicate key overwrites:
+  #     `old_key` and takes its return value as `new_key`; sets
+  #     <code>new_hash[new_key] = value</code>; a duplicate key overwrites:
   #
   #         h = {foo: 0, bar: 1, baz: 2}
   #         h.transform_keys(baz: :BAZ) {|key| key.to_s.reverse }
@@ -1866,7 +1870,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   # Values](rdoc-ref:Hash@Methods+for+Transforming+Keys+and+Values).
   #
   def transform_keys: () -> Enumerator[K, Hash[untyped, V]]
+                    | [A] (Hash[K, A]) -> Hash[A, V]
                     | [A] () { (K) -> A } -> Hash[A, V]
+                    | [A] (Hash[K, A]) { (K) -> A } -> Hash[A, V]
 
   # <!--
   #   rdoc-file=hash.c
@@ -1881,10 +1887,10 @@ class Hash[unchecked out K, unchecked out V] < Object
   # With a block given and no argument, derives keys only from the block; all,
   # some, or none of the keys in `self` may be changed.
   #
-  # For each key/value pair `old_key/value` in `self`, calls the block with
-  # `old_key`; the block's return value becomes `new_key`; removes the entry for
-  # `old_key`: `self.delete(old_key)`; sets `self[new_key] = value`; a duplicate
-  # key overwrites:
+  # For each key/value pair <code>old_key/value</code> in `self`, calls the block
+  # with `old_key`; the block's return value becomes `new_key`; removes the entry
+  # for `old_key`: <code>self.delete(old_key)</code>; sets <code>self[new_key] =
+  # value</code>; a duplicate key overwrites:
   #
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.transform_keys! {|old_key| old_key.to_s }
@@ -1897,12 +1903,13 @@ class Hash[unchecked out K, unchecked out V] < Object
   # `other_hash` and `self`; all, some, or none of the keys in `self` may be
   # changed.
   #
-  # For each key/value pair `old_key/old_value` in `self`, looks for key `old_key`
-  # in `other_hash`:
+  # For each key/value pair <code>old_key/old_value</code> in `self`, looks for
+  # key `old_key` in `other_hash`:
   #
-  # *   If `old_key` is found, takes value `other_hash[old_key]` as `new_key`;
-  #     removes the entry for `old_key`: `self.delete(old_key)`; sets
-  #     `self[new_key] = value`; a duplicate key overwrites:
+  # *   If `old_key` is found, takes value <code>other_hash[old_key]</code> as
+  #     `new_key`; removes the entry for `old_key`:
+  #     <code>self.delete(old_key)</code>; sets <code>self[new_key] =
+  #     value</code>; a duplicate key overwrites:
   #
   #         h = {foo: 0, bar: 1, baz: 2}
   #         h.transform_keys!(baz: :BAZ, bar: :BAR, foo: :FOO)
@@ -1933,8 +1940,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # *   If `other_hash` has key `old_key` (with value `new_key`), does not call
   #     the block for that key; removes the entry for `old_key`:
-  #     `self.delete(old_key)`; sets `self[new_key] = value`; a duplicate key
-  #     overwrites:
+  #     <code>self.delete(old_key)</code>; sets <code>self[new_key] =
+  #     value</code>; a duplicate key overwrites:
   #
   #         h = {foo: 0, bar: 1, baz: 2}
   #         h.transform_keys!(baz: :BAZ, bar: :BAR, foo: :FOO) {|key| fail 'Not called' }
@@ -1942,8 +1949,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # *   If `other_hash` does not have key `old_key`, calls the block with
   #     `old_key` and takes its return value as `new_key`; removes the entry for
-  #     `old_key`: `self.delete(old_key)`; sets `self[new_key] = value`; a
-  #     duplicate key overwrites:
+  #     `old_key`: <code>self.delete(old_key)</code>; sets <code>self[new_key] =
+  #     value</code>; a duplicate key overwrites:
   #
   #         h = {foo: 0, bar: 1, baz: 2}
   #         h.transform_keys!(baz: :BAZ) {|key| key.to_s.reverse }
@@ -1958,7 +1965,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   # Values](rdoc-ref:Hash@Methods+for+Transforming+Keys+and+Values).
   #
   def transform_keys!: () -> Enumerator[K, self]
+                     | (Hash[K, K]) -> self
                      | () { (K) -> K } -> self
+                     | (Hash[K, K]) { (K) -> K } -> self
 
   # <!--
   #   rdoc-file=hash.c
@@ -1990,7 +1999,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   # returns `self`.
   #
   # For each entry `key`/`old_value` in `self`, calls the block with `old_value`,
-  # captures its return value as `new_value`, and sets `self[key] = new_value`:
+  # captures its return value as `new_value`, and sets <code>self[key] =
+  # new_value</code>:
   #
   #     h = {foo: 0, bar: 1, baz: 2}
   #     h.transform_values! {|value| value * 100} # => {foo: 0, bar: 100, baz: 200}
@@ -2015,8 +2025,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   # With no block given, for each successive entry `key`/`new_value` in each
   # successive `other_hash`:
   #
-  # *   If `key` is in `self`, sets `self[key] = new_value`, whose position is
-  #     unchanged:
+  # *   If `key` is in `self`, sets <code>self[key] = new_value</code>, whose
+  #     position is unchanged:
   #
   #         h0 = {foo: 0, bar: 1, baz: 2}
   #         h1 = {bar: 3, foo: -1}
@@ -2030,9 +2040,9 @@ class Hash[unchecked out K, unchecked out V] < Object
   # With a block given, for each successive entry `key`/`new_value` in each
   # successive `other_hash`:
   #
-  # *   If `key` is in `self`, fetches `old_value` from `self[key]`, calls the
-  #     block with `key`, `old_value`, and `new_value`, and sets `self[key] =
-  #     new_value`, whose position is unchanged  :
+  # *   If `key` is in `self`, fetches `old_value` from <code>self[key]</code>,
+  #     calls the block with `key`, `old_value`, and `new_value`, and sets
+  #     <code>self[key] = new_value</code>, whose position is unchanged  :
   #
   #         season = {AB: 75, H: 20, HR: 3, SO: 17, W: 11, HBP: 3}
   #         today = {AB: 3, H: 1, W: 1}

data/core/integer.rbs

@@ -88,7 +88,7 @@
 # *   #downto: Calls the given block with each integer value from `self` down to
 #     the given value.
 # *   #times: Calls the given block `self` times with each integer in
-#     `(0..self-1)`.
+#     <code>(0..self-1)</code>.
 # *   #upto: Calls the given block with each integer value from `self` up to the
 #     given value.
 #
@@ -114,9 +114,9 @@ class Integer < Numeric
   #     Integer.sqrt(4.0)            # => 2
   #     Integer.sqrt(3.14159)        # => 1
   #
-  # This method is equivalent to `Math.sqrt(numeric).floor`, except that the
-  # result of the latter code may differ from the true value due to the limited
-  # precision of floating point arithmetic.
+  # This method is equivalent to <code>Math.sqrt(numeric).floor</code>, except
+  # that the result of the latter code may differ from the true value due to the
+  # limited precision of floating point arithmetic.
   #
   #     Integer.sqrt(10**46)    # => 100000000000000000000000
   #     Math.sqrt(10**46).floor # => 99999999999999991611392
@@ -132,14 +132,15 @@ class Integer < Numeric
   # If `object` is an Integer object, returns `object`.
   #     Integer.try_convert(1) # => 1
   #
-  # Otherwise if `object` responds to `:to_int`, calls `object.to_int` and returns
-  # the result.
+  # Otherwise if `object` responds to <code>:to_int</code>, calls
+  # <code>object.to_int</code> and returns the result.
   #     Integer.try_convert(1.25) # => 1
   #
-  # Returns `nil` if `object` does not respond to `:to_int`
+  # Returns `nil` if `object` does not respond to <code>:to_int</code>
   #     Integer.try_convert([]) # => nil
   #
-  # Raises an exception unless `object.to_int` returns an Integer object.
+  # Raises an exception unless <code>object.to_int</code> returns an Integer
+  # object.
   #
   def self.try_convert: (int) -> Integer
                       | (untyped) -> Integer?
@@ -280,8 +281,6 @@ class Integer < Numeric
        | (Rational) -> Rational
        | (Complex) -> Complex
 
-  def +@: () -> Integer
-
   # <!--
   #   rdoc-file=numeric.c
   #   - self - other -> numeric
@@ -393,7 +392,7 @@ class Integer < Numeric
   #
   # Returns:
   #
-  # *   `-1`, if `self` is less than `other`.
+  # *   <code>-1</code>, if `self` is less than `other`.
   # *   `0`, if `self` is equal to `other`.
   # *   `1`, if `self` is greater then `other`.
   # *   `nil`, if `self` and `other` are incomparable.
@@ -504,8 +503,8 @@ class Integer < Numeric
   #     n[2]     # => 0
   #     n[3]     # => 0
   #
-  # In principle, `n[i]` is equivalent to `(n >> i) & 1`. Thus, negative index
-  # always returns zero:
+  # In principle, <code>n[i]</code> is equivalent to <code>(n >> i) & 1</code>.
+  # Thus, negative index always returns zero:
   #
   #     255[-1] # => 0
   #
@@ -516,8 +515,9 @@ class Integer < Numeric
   #     "%010b" % n[0, 10] # => "0000111000"
   #     "%010b" % n[4, 10] # => "0000000011"
   #
-  # With argument `range`, returns `range.size` bits from `self`, beginning at
-  # `range.begin` and including bits of greater significance:
+  # With argument `range`, returns <code>range.size</code> bits from `self`,
+  # beginning at <code>range.begin</code> and including bits of greater
+  # significance:
   #
   #     n = 0b111000      # => 56
   #     "%010b" % n[0..9] # => "0000111000"
@@ -556,8 +556,6 @@ class Integer < Numeric
   #
   def abs: () -> Integer
 
-  def abs2: () -> Integer
-
   # <!--
   #   rdoc-file=numeric.c
   #   - allbits?(mask) -> true or false
@@ -581,8 +579,6 @@ class Integer < Numeric
   #
   def allbits?: (int mask) -> bool
 
-  def angle: () -> (Integer | Float)
-
   # <!--
   #   rdoc-file=numeric.c
   #   - anybits?(mask) -> true or false
@@ -617,7 +613,7 @@ class Integer < Numeric
   # significant bit has bit position 1). If there is no such bit (zero or minus
   # one), returns zero.
   #
-  # This method returns `ceil(log2(self < 0 ? -self : self + 1))`>.
+  # This method returns <code>ceil(log2(self < 0 ? -self : self + 1))</code>>.
   #
   #     (-2**1000-1).bit_length   # => 1001
   #     (-2**1000).bit_length     # => 1000
@@ -670,7 +666,7 @@ class Integer < Numeric
   #
   # *   When `self` is non-zero and `ndigits` is negative,
   #      returns a value based on a computed granularity:
-  #     *   The granularity is `10 ** ndigits.abs`.
+  #     *   The granularity is <code>10 ** ndigits.abs</code>.
   #     *   The returned value is the smallest multiple of the granularity
   #          that is greater than or equal to `self`.
   #     Examples with positive `self`:
@@ -747,10 +743,6 @@ class Integer < Numeric
   #
   def coerce: (Numeric) -> [ Numeric, Numeric ]
 
-  def conj: () -> Integer
-
-  def conjugate: () -> Integer
-
   # <!--
   #   rdoc-file=numeric.rb
   #   - denominator -> 1
@@ -796,7 +788,7 @@ class Integer < Numeric
   #   rdoc-file=numeric.c
   #   - divmod(other) -> array
   # -->
-  # Returns a 2-element array `[q, r]`, where
+  # Returns a 2-element array <code>[q, r]</code>, where
   #
   #     q = (self/other).floor    # Quotient
   #     r = self % other          # Remainder
@@ -842,10 +834,6 @@ class Integer < Numeric
   def downto: (Numeric limit) { (Integer) -> void } -> Integer
             | (Numeric limit) -> ::Enumerator[Integer, self]
 
-  def dup: () -> self
-
-  def eql?: (untyped) -> bool
-
   # <!--
   #   rdoc-file=numeric.rb
   #   - even? -> true or false
@@ -870,8 +858,6 @@ class Integer < Numeric
   #
   def fdiv: (Numeric) -> Float
 
-  def finite?: () -> bool
-
   # <!--
   #   rdoc-file=numeric.c
   #   - floor(ndigits = 0) -> integer
@@ -891,7 +877,7 @@ class Integer < Numeric
   #
   # *   When `self` is non-zero and `ndigits` is negative,
   #      returns a value based on a computed granularity:
-  #     *   The granularity is `10 ** ndigits.abs`.
+  #     *   The granularity is <code>10 ** ndigits.abs</code>.
   #     *   The returned value is the largest multiple of the granularity
   #          that is less than or equal to `self`.
   #     Examples with positive `self`:
@@ -942,14 +928,6 @@ class Integer < Numeric
   #
   def gcdlcm: (Integer) -> [ Integer, Integer ]
 
-  def i: () -> Complex
-
-  def imag: () -> Integer
-
-  def imaginary: () -> Integer
-
-  def infinite?: () -> Integer?
-
   # <!-- rdoc-file=numeric.c -->
   # Returns a string containing the place-value representation of `self` in radix
   # `base` (in 2..36).
@@ -1024,7 +1002,7 @@ class Integer < Numeric
   def negative?: () -> bool
 
   # <!-- rdoc-file=numeric.c -->
-  # Returns the successor integer of `self` (equivalent to `self + 1`):
+  # Returns the successor integer of `self` (equivalent to <code>self + 1</code>):
   #
   #     1.succ  #=> 2
   #     -1.succ #=> 0
@@ -1056,8 +1034,6 @@ class Integer < Numeric
   #
   def nobits?: (int mask) -> bool
 
-  def nonzero?: () -> self?
-
   # <!--
   #   rdoc-file=numeric.rb
   #   - numerator -> self
@@ -1082,8 +1058,6 @@ class Integer < Numeric
   #
   def ord: () -> Integer
 
-  alias phase angle
-
   def polar: () -> [ Integer, Integer | Float ]
 
   def positive?: () -> bool
@@ -1108,7 +1082,7 @@ class Integer < Numeric
   #   rdoc-file=numeric.c
   #   - pred -> next_integer
   # -->
-  # Returns the predecessor of `self` (equivalent to `self - 1`):
+  # Returns the predecessor of `self` (equivalent to <code>self - 1</code>):
   #
   #     1.pred  #=> 0
   #     -1.pred #=> -2
@@ -1132,14 +1106,8 @@ class Integer < Numeric
   #
   def rationalize: (?Numeric eps) -> Rational
 
-  def real: () -> self
-
-  def real?: () -> true
-
   def rect: () -> [ Integer, Numeric ]
 
-  alias rectangular rect
-
   # <!--
   #   rdoc-file=numeric.c
   #   - remainder(other) -> real_number
@@ -1173,8 +1141,8 @@ class Integer < Numeric
   # Returns `self` rounded to the nearest value with a precision of `ndigits`
   # decimal digits.
   #
-  # When `ndigits` is negative, the returned value has at least `ndigits.abs`
-  # trailing zeros:
+  # When `ndigits` is negative, the returned value has at least
+  # <code>ndigits.abs</code> trailing zeros:
   #
   #     555.round(-1)      # => 560
   #     555.round(-2)      # => 600
@@ -1191,17 +1159,18 @@ class Integer < Numeric
   # If keyword argument `half` is given, and `self` is equidistant from the two
   # candidate  values, the rounding is according to the given `half` value:
   #
-  # *   `:up` or `nil`: round away from zero:
+  # *   <code>:up</code> or `nil`: round away from zero:
   #
   #         25.round(-1, half: :up)      # => 30
   #         (-25).round(-1, half: :up)   # => -30
   #
-  # *   `:down`: round toward zero:
+  # *   <code>:down</code>: round toward zero:
   #
   #         25.round(-1, half: :down)    # => 20
   #         (-25).round(-1, half: :down) # => -20
   #
-  # *   `:even`: round toward the candidate whose last nonzero digit is even:
+  # *   <code>:even</code>: round toward the candidate whose last nonzero digit is
+  #     even:
   #
   #         25.round(-1, half: :even)    # => 20
   #         15.round(-1, half: :even)    # => 20
@@ -1230,22 +1199,11 @@ class Integer < Numeric
   #
   def size: () -> Integer
 
-  def step: () { (Integer) -> void } -> void
-          | (Numeric limit, ?Integer step) { (Integer) -> void } -> void
-          | (Numeric limit, ?Numeric step) { (Numeric) -> void } -> void
-          | (to: Numeric, ?by: Integer) { (Integer) -> void } -> void
-          | (by: Numeric, ?to: Numeric) { (Numeric) -> void } -> void
-          | () -> Enumerator[Integer, bot]
-          | (Numeric limit, ?Integer step) -> Enumerator[Integer]
-          | (Numeric limit, ?Numeric step) -> Enumerator[Numeric]
-          | (to: Numeric, ?by: Integer) -> Enumerator[Integer]
-          | (by: Numeric, ?to: Numeric) -> Enumerator[Numeric]
-
   # <!--
   #   rdoc-file=numeric.c
   #   - succ -> next_integer
   # -->
-  # Returns the successor integer of `self` (equivalent to `self + 1`):
+  # Returns the successor integer of `self` (equivalent to <code>self + 1</code>):
   #
   #     1.succ  #=> 2
   #     -1.succ #=> 0
@@ -1259,7 +1217,8 @@ class Integer < Numeric
   #   - times {|i| ... } -> self
   #   - times            -> enumerator
   # -->
-  # Calls the given block `self` times with each integer in `(0..self-1)`:
+  # Calls the given block `self` times with each integer in
+  # <code>(0..self-1)</code>:
   #
   #     a = []
   #     5.times {|i| a.push(i) } # => 5
@@ -1270,8 +1229,6 @@ class Integer < Numeric
   def times: () { (Integer) -> void } -> self
            | () -> ::Enumerator[Integer, self]
 
-  def to_c: () -> Complex
-
   # <!--
   #   rdoc-file=numeric.c
   #   - to_f -> float
@@ -1377,8 +1334,8 @@ class Integer < Numeric
   # Returns `self` truncated (toward zero) to a precision of `ndigits` decimal
   # digits.
   #
-  # When `ndigits` is negative, the returned value has at least `ndigits.abs`
-  # trailing zeros:
+  # When `ndigits` is negative, the returned value has at least
+  # <code>ndigits.abs</code> trailing zeros:
   #
   #     555.truncate(-1)  # => 550
   #     555.truncate(-2)  # => 500