rbs 4.0.0.dev.5 → 4.0.1.dev.1

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?
@@ -391,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.
@@ -502,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
   #
@@ -514,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"
@@ -611,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
@@ -664,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`:
@@ -786,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
@@ -875,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`:
@@ -1000,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
@@ -1080,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
@@ -1139,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
@@ -1157,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
@@ -1200,7 +1203,7 @@ class Integer < 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
@@ -1214,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
@@ -1330,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

data/core/io/buffer.rbs

@@ -81,9 +81,9 @@ class IO
   #     File.read('test.txt')
   #     # => "t--- data"
   #
-  # **The class is experimental and the interface is subject to change, this is
-  # especially true of file mappings which may be removed entirely in the
-  # future.**
+  # <strong>The class is experimental and the interface is subject to change, this
+  # is especially true of file mappings which may be removed entirely in the
+  # future.</strong>
   #
   class Buffer
     include Comparable
@@ -356,7 +356,7 @@ class IO
     #   - get_string([offset, [length, [encoding]]]) -> string
     # -->
     # Read a chunk or all of the buffer into a string, in the specified `encoding`.
-    # If no encoding is provided `Encoding::BINARY` is used.
+    # If no encoding is provided <code>Encoding::BINARY</code> is used.
     #
     #     buffer = IO::Buffer.for('test')
     #     buffer.get_string
@@ -375,32 +375,32 @@ class IO
     # Read from buffer a value of `type` at `offset`. `buffer_type` should be one of
     # symbols:
     #
-    # *   `:U8`: unsigned integer, 1 byte
-    # *   `:S8`: signed integer, 1 byte
-    # *   `:u16`: unsigned integer, 2 bytes, little-endian
-    # *   `:U16`: unsigned integer, 2 bytes, big-endian
-    # *   `:s16`: signed integer, 2 bytes, little-endian
-    # *   `:S16`: signed integer, 2 bytes, big-endian
-    # *   `:u32`: unsigned integer, 4 bytes, little-endian
-    # *   `:U32`: unsigned integer, 4 bytes, big-endian
-    # *   `:s32`: signed integer, 4 bytes, little-endian
-    # *   `:S32`: signed integer, 4 bytes, big-endian
-    # *   `:u64`: unsigned integer, 8 bytes, little-endian
-    # *   `:U64`: unsigned integer, 8 bytes, big-endian
-    # *   `:s64`: signed integer, 8 bytes, little-endian
-    # *   `:S64`: signed integer, 8 bytes, big-endian
-    # *   `:u128`: unsigned integer, 16 bytes, little-endian
-    # *   `:U128`: unsigned integer, 16 bytes, big-endian
-    # *   `:s128`: signed integer, 16 bytes, little-endian
-    # *   `:S128`: signed integer, 16 bytes, big-endian
-    # *   `:f32`: float, 4 bytes, little-endian
-    # *   `:F32`: float, 4 bytes, big-endian
-    # *   `:f64`: double, 8 bytes, little-endian
-    # *   `:F64`: double, 8 bytes, big-endian
+    # *   <code>:U8</code>: unsigned integer, 1 byte
+    # *   <code>:S8</code>: signed integer, 1 byte
+    # *   <code>:u16</code>: unsigned integer, 2 bytes, little-endian
+    # *   <code>:U16</code>: unsigned integer, 2 bytes, big-endian
+    # *   <code>:s16</code>: signed integer, 2 bytes, little-endian
+    # *   <code>:S16</code>: signed integer, 2 bytes, big-endian
+    # *   <code>:u32</code>: unsigned integer, 4 bytes, little-endian
+    # *   <code>:U32</code>: unsigned integer, 4 bytes, big-endian
+    # *   <code>:s32</code>: signed integer, 4 bytes, little-endian
+    # *   <code>:S32</code>: signed integer, 4 bytes, big-endian
+    # *   <code>:u64</code>: unsigned integer, 8 bytes, little-endian
+    # *   <code>:U64</code>: unsigned integer, 8 bytes, big-endian
+    # *   <code>:s64</code>: signed integer, 8 bytes, little-endian
+    # *   <code>:S64</code>: signed integer, 8 bytes, big-endian
+    # *   <code>:u128</code>: unsigned integer, 16 bytes, little-endian
+    # *   <code>:U128</code>: unsigned integer, 16 bytes, big-endian
+    # *   <code>:s128</code>: signed integer, 16 bytes, little-endian
+    # *   <code>:S128</code>: signed integer, 16 bytes, big-endian
+    # *   <code>:f32</code>: float, 4 bytes, little-endian
+    # *   <code>:F32</code>: float, 4 bytes, big-endian
+    # *   <code>:f64</code>: double, 8 bytes, little-endian
+    # *   <code>:F64</code>: double, 8 bytes, big-endian
     #
     # A buffer type refers specifically to the type of binary buffer that is stored
-    # in the buffer. For example, a `:u32` buffer type is a 32-bit unsigned integer
-    # in little-endian format.
+    # in the buffer. For example, a <code>:u32</code> buffer type is a 32-bit
+    # unsigned integer in little-endian format.
     #
     #     string = [1.5].pack('f')
     #     # => "\x00\x00\xC0?"
@@ -557,7 +557,7 @@ class IO
     # -->
     # Read at least `length` bytes from the `io` starting at the specified `from`
     # position, into the buffer starting at `offset`. If an error occurs, return
-    # `-errno`.
+    # <code>-errno</code>.
     #
     # If `length` is not given or `nil`, it defaults to the size of the buffer minus
     # the offset, i.e. the entire buffer.
@@ -590,7 +590,7 @@ class IO
     # -->
     # Write at least `length` bytes from the buffer starting at `offset`, into the
     # `io` starting at the specified `from` position. If an error occurs, return
-    # `-errno`.
+    # <code>-errno</code>.
     #
     # If `length` is not given or `nil`, it defaults to the size of the buffer minus
     # the offset, i.e. the entire buffer.
@@ -607,7 +607,7 @@ class IO
     #     IO::Buffer.for('1234567').pwrite(out, 2, 3, 1)
     #
     # This leads to `234` (3 bytes, starting from position 1) being written into
-    # `output.txt`, starting from file position 2.
+    # <code>output.txt</code>, starting from file position 2.
     #
     def pwrite: (untyped, untyped, untyped) -> untyped
 
@@ -616,7 +616,7 @@ class IO
     #   - read(io, [length, [offset]]) -> read length or -errno
     # -->
     # Read at least `length` bytes from the `io`, into the buffer starting at
-    # `offset`. If an error occurs, return `-errno`.
+    # `offset`. If an error occurs, return <code>-errno</code>.
     #
     # If `length` is not given or `nil`, it defaults to the size of the buffer minus
     # the offset, i.e. the entire buffer.
@@ -756,8 +756,8 @@ class IO
     # minus the specified offset. If the length is negative, it will raise an
     # ArgumentError.
     #
-    # Raises RuntimeError if the `offset+length` is out of the current buffer's
-    # bounds.
+    # Raises RuntimeError if the <code>offset+length</code> is out of the current
+    # buffer's bounds.
     #
     #     string = 'test'
     #     buffer = IO::Buffer.for(string).dup
@@ -841,7 +841,7 @@ class IO
     #   - write(io, [length, [offset]]) -> written length or -errno
     # -->
     # Write at least `length` bytes from the buffer starting at `offset`, into the
-    # `io`. If an error occurs, return `-errno`.
+    # `io`. If an error occurs, return <code>-errno</code>.
     #
     # If `length` is not given or `nil`, it defaults to the size of the buffer minus
     # the offset, i.e. the entire buffer.
@@ -854,7 +854,7 @@ class IO
     #     out = File.open('output.txt', 'wb')
     #     IO::Buffer.for('1234567').write(out, 3)
     #
-    # This leads to `123` being written into `output.txt`
+    # This leads to `123` being written into <code>output.txt</code>
     #
     def write: (untyped, untyped) -> untyped