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

data/core/ractor.rbs

@@ -96,8 +96,9 @@
 # object.
 #
 # Deep cloning of objects may be slow, and sometimes impossible. Alternatively,
-# `move: true` may be used during sending. This will *move* the unshareable
-# object to the receiving ractor, making it inaccessible to the sending ractor.
+# <code>move: true</code> may be used during sending. This will *move* the
+# unshareable object to the receiving ractor, making it inaccessible to the
+# sending ractor.
 #
 #     data = ['foo', 'bar']
 #     r = Ractor.new do
@@ -171,8 +172,8 @@
 #     # I see C
 #     # can not access instance variables of classes/modules from non-main Ractors (RuntimeError)
 #
-# See also the description of `# shareable_constant_value` pragma in [Comments
-# syntax](rdoc-ref:syntax/comments.rdoc) explanation.
+# See also the description of <code># shareable_constant_value</code> pragma in
+# [Comments syntax](rdoc-ref:syntax/comments.rdoc) explanation.
 #
 # ## Ractors vs threads
 #
@@ -392,9 +393,10 @@ class Ractor
   #     # r1 done
   #     # r0 done
   #
-  # The following example is almost equivalent to `ractors.map(&:value)` except
-  # the thread is unblocked when any of the ractors has terminated as opposed to
-  # waiting for their termination in the array element order.
+  # The following example is almost equivalent to
+  # <code>ractors.map(&:value)</code> except the thread is unblocked when any of
+  # the ractors has terminated as opposed to waiting for their termination in the
+  # array element order.
   #
   #     values = []
   #     until ractors.empty?
@@ -425,8 +427,8 @@ class Ractor
   #   - Ractor.shareable_proc(self: nil){} -> shareable proc
   # -->
   # Returns a shareable copy of the given block's Proc. The value of `self` in the
-  # Proc will be replaced with the value passed via the `self:` keyword, or `nil`
-  # if not given.
+  # Proc will be replaced with the value passed via the <code>self:</code>
+  # keyword, or `nil` if not given.
   #
   # In a shareable Proc, access to any outer variables if prohibited.
   #
@@ -539,8 +541,10 @@ class Ractor
   # Registers the port as a monitoring port for this ractor. When the ractor
   # terminates, the port receives a Symbol object.
   #
-  # *   `:exited` is sent if the ractor terminates without an unhandled exception.
-  # *   `:aborted` is sent if the ractor terminates by an unhandled exception.
+  # *   <code>:exited</code> is sent if the ractor terminates without an unhandled
+  #     exception.
+  # *   <code>:aborted</code> is sent if the ractor terminates by an unhandled
+  #     exception.
   #
   #         r = Ractor.new{ some_task() }
   #         r.monitor(port = Ractor::Port.new)

data/core/random.rbs

@@ -190,9 +190,10 @@ end
 # <!-- rdoc-file=lib/random/formatter.rb -->
 # ## Random number formatter.
 #
-# Formats generated random numbers in many manners. When `'random/formatter'` is
-# required, several methods are added to empty core module `Random::Formatter`,
-# making them available as Random's instance and module methods.
+# Formats generated random numbers in many manners. When
+# <code>'random/formatter'</code> is required, several methods are added to
+# empty core module <code>Random::Formatter</code>, making them available as
+# Random's instance and module methods.
 #
 # Standard library SecureRandom is also extended with the module, and the
 # methods described below are available as a module methods in it.

data/core/range.rbs

@@ -98,8 +98,9 @@
 # ## Ranges and Other Classes
 #
 # An object may be put into a range if its class implements instance method
-# `#<=>`. Ruby core classes that do so include Array, Complex, File::Stat,
-# Float, Integer, Kernel, Module, Numeric, Rational, String, Symbol, and Time.
+# <code>#<=></code>. Ruby core classes that do so include Array, Complex,
+# File::Stat, Float, Integer, Kernel, Module, Numeric, Rational, String, Symbol,
+# and Time.
 #
 # Example:
 #
@@ -128,12 +129,13 @@
 # ## Ranges and User-Defined Classes
 #
 # A user-defined class that is to be used in a range must implement instance
-# method `#<=>`; see Integer#<=>. To make iteration available, it must also
-# implement instance method `succ`; see Integer#succ.
+# method <code>#<=></code>; see Integer#<=>. To make iteration available, it
+# must also implement instance method `succ`; see Integer#succ.
 #
-# The class below implements both `#<=>` and `succ`, and so can be used both to
-# construct ranges and to iterate over them. Note that the Comparable module is
-# included so the `==` method is defined in terms of `#<=>`.
+# The class below implements both <code>#<=></code> and `succ`, and so can be
+# used both to construct ranges and to iterate over them. Note that the
+# Comparable module is included so the <code>==</code> method is defined in
+# terms of <code>#<=></code>.
 #
 #     # Represent a string of 'X' characters.
 #     class Xs
@@ -268,9 +270,9 @@ class Range[out Elem] < Object
   # Returns `true` if and only if:
   #
   # *   `other` is a range.
-  # *   `other.begin == self.begin`.
-  # *   `other.end == self.end`.
-  # *   `other.exclude_end? == self.exclude_end?`.
+  # *   <code>other.begin == self.begin</code>.
+  # *   <code>other.end == self.end</code>.
+  # *   <code>other.exclude_end? == self.exclude_end?</code>.
   #
   # Otherwise returns `false`.
   #
@@ -297,8 +299,8 @@ class Range[out Elem] < Object
   #   rdoc-file=range.c
   #   - self === object ->  true or false
   # -->
-  # Returns `true` if `object` is between `self.begin` and `self.end`. `false`
-  # otherwise:
+  # Returns `true` if `object` is between <code>self.begin</code> and
+  # <code>self.end</code>. `false` otherwise:
   #
   #     (1..4) === 2       # => true
   #     (1..4) === 5       # => false
@@ -308,7 +310,7 @@ class Range[out Elem] < Object
   #     ('a'..'d') === 'c' # => true
   #     ('a'..'d') === 'e' # => false
   #
-  # A case statement uses method `===`, and so:
+  # A case statement uses method <code>===</code>, and so:
   #
   #     case 79
   #     when (1..50)
@@ -364,10 +366,11 @@ class Range[out Elem] < Object
   # -->
   # Returns `true` if the given argument is within `self`, `false` otherwise.
   #
-  # With non-range argument `object`, evaluates with `<=` and `<`.
+  # With non-range argument `object`, evaluates with <code><=</code> and
+  # <code><</code>.
   #
-  # For range `self` with included end value (`#exclude_end? == false`), evaluates
-  # thus:
+  # For range `self` with included end value (<code>#exclude_end? ==
+  # false</code>), evaluates thus:
   #
   #     self.begin <= object <= self.end
   #
@@ -387,8 +390,8 @@ class Range[out Elem] < Object
   #     r.cover?('e')     # => false
   #     r.cover?(0)       # => false
   #
-  # For range `r` with excluded end value (`#exclude_end? == true`), evaluates
-  # thus:
+  # For range `r` with excluded end value (<code>#exclude_end? == true</code>),
+  # evaluates thus:
   #
   #     r.begin <= object < r.end
   #
@@ -434,8 +437,8 @@ class Range[out Elem] < Object
   # Returns `false` if either:
   #
   # *   The begin value of `self` is larger than its end value.
-  # *   An internal call to `#<=>` returns `nil`; that is, the operands are not
-  #     comparable.
+  # *   An internal call to <code>#<=></code> returns `nil`; that is, the operands
+  #     are not comparable.
   #
   # Beginless ranges cover all values of the same type before the end, excluding
   # the end for exclusive ranges. Beginless ranges cover ranges that end before
@@ -493,7 +496,7 @@ class Range[out Elem] < Object
   #     (1..4).each {|element| a.push(element) } # => 1..4
   #     a # => [1, 2, 3, 4]
   #
-  # Raises an exception unless `self.first.respond_to?(:succ)`.
+  # Raises an exception unless <code>self.first.respond_to?(:succ)</code>.
   #
   # With no block given, returns an enumerator.
   #
@@ -556,7 +559,7 @@ class Range[out Elem] < Object
   #   - hash -> integer
   # -->
   # Returns the integer hash value for `self`. Two range objects `r0` and `r1`
-  # have the same hash value if and only if `r0.eql?(r1)`.
+  # have the same hash value if and only if <code>r0.eql?(r1)</code>.
   #
   # Related: Range#eql?, Object#hash.
   #
@@ -608,8 +611,8 @@ class Range[out Elem] < Object
   #   rdoc-file=range.c
   #   - inspect -> string
   # -->
-  # Returns a string representation of `self`, including `begin.inspect` and
-  # `end.inspect`:
+  # Returns a string representation of `self`, including
+  # <code>begin.inspect</code> and <code>end.inspect</code>:
   #
   #     (1..4).inspect  # => "1..4"
   #     (1...4).inspect # => "1...4"
@@ -668,8 +671,8 @@ class Range[out Elem] < Object
   #   - max {|a, b| ... } -> object
   #   - max(n) {|a, b| ... } -> array
   # -->
-  # Returns the maximum value in `self`, using method `#<=>` or a given block for
-  # comparison.
+  # Returns the maximum value in `self`, using method <code>#<=></code> or a given
+  # block for comparison.
   #
   # With no argument and no block given, returns the maximum-valued element of
   # `self`.
@@ -736,7 +739,7 @@ class Range[out Elem] < Object
   #
   # Raises an exception if either:
   #
-  # *   `self` is a endless range: `(1..)`.
+  # *   `self` is a endless range: <code>(1..)</code>.
   # *   A block is given and `self` is a beginless range.
   #
   # Related: Range#min, Range#minmax.
@@ -750,8 +753,8 @@ class Range[out Elem] < Object
   #   - min {|a, b| ... } -> object
   #   - min(n) {|a, b| ... } -> array
   # -->
-  # Returns the minimum value in `self`, using method `#<=>` or a given block for
-  # comparison.
+  # Returns the minimum value in `self`, using method <code>#<=></code> or a given
+  # block for comparison.
   #
   # With no argument and no block given, returns the minimum-valued element of
   # `self`.
@@ -818,7 +821,7 @@ class Range[out Elem] < Object
   #
   # Raises an exception if either:
   #
-  # *   `self` is a beginless range: `(..4)`.
+  # *   `self` is a beginless range: <code>(..4)</code>.
   # *   A block is given and `self` is an endless range.
   #
   # Related: Range#max, Range#minmax.
@@ -831,10 +834,10 @@ class Range[out Elem] < Object
   #   - minmax {|a, b| ... } -> [object, object]
   # -->
   # Returns a 2-element array containing the minimum and maximum value in `self`,
-  # either according to comparison method `#<=>` or a given block.
+  # either according to comparison method <code>#<=></code> or a given block.
   #
-  # With no block given, returns the minimum and maximum values, using `#<=>` for
-  # comparison:
+  # With no block given, returns the minimum and maximum values, using
+  # <code>#<=></code> for comparison:
   #
   #     (1..4).minmax     # => [1, 4]
   #     (1...4).minmax    # => [1, 3]
@@ -847,12 +850,13 @@ class Range[out Elem] < Object
   # *   Zero if `a` and `b` are equal.
   # *   Positive if `a` is larger than `b`.
   #
-  # The block is called `self.size` times to compare elements; returns a 2-element
-  # Array containing the minimum and maximum values from `self`, per the block:
+  # The block is called <code>self.size</code> times to compare elements; returns
+  # a 2-element Array containing the minimum and maximum values from `self`, per
+  # the block:
   #
   #     (1..4).minmax {|a, b| -(a <=> b) } # => [4, 1]
   #
-  # Returns `[nil, nil]` if:
+  # Returns <code>[nil, nil]</code> if:
   #
   # *   The begin value of the range is larger than the end value:
   #
@@ -884,8 +888,8 @@ class Range[out Elem] < Object
   #
   #     (1..3).overlap?(1)         # TypeError
   #
-  # Returns `false` if an internal call to `#<=>` returns `nil`; that is, the
-  # operands are not comparable.
+  # Returns `false` if an internal call to <code>#<=></code> returns `nil`; that
+  # is, the operands are not comparable.
   #
   #     (1..3).overlap?('a'..'d')  # => false
   #
@@ -929,7 +933,8 @@ class Range[out Elem] < Object
   #     (...[]).overlap?(...[]) # => true
   #
   # Even if those ranges are effectively empty (no number can be smaller than
-  # `-Float::INFINITY`), they are still considered overlapping with themselves.
+  # <code>-Float::INFINITY</code>), they are still considered overlapping with
+  # themselves.
   #
   # Related: Range#cover?.
   #
@@ -1019,7 +1024,7 @@ class Range[out Elem] < Object
   #   - step(s = 1)                  -> enumerator/arithmetic_sequence
   # -->
   # Iterates over the elements of range in steps of `s`. The iteration is
-  # performed by `+` operator:
+  # performed by <code>+</code> operator:
   #
   #     (0..6).step(2) { puts _1 } #=> 1..5
   #     # Prints: 0, 2, 4, 6
@@ -1034,8 +1039,8 @@ class Range[out Elem] < Object
   #     #   2022-02-28 00:00:00 UTC
   #     #   2022-03-01 00:00:00 UTC
   #
-  # If ` + step` decreases the value, iteration is still performed when step
-  # `begin` is higher than the `end`:
+  # If <code> + step</code> decreases the value, iteration is still performed when
+  # step `begin` is higher than the `end`:
   #
   #     (0..6).step(-2) { puts _1 }
   #     # Prints nothing
@@ -1100,8 +1105,8 @@ class Range[out Elem] < Object
   #   rdoc-file=range.c
   #   - to_s -> string
   # -->
-  # Returns a string representation of `self`, including `begin.to_s` and
-  # `end.to_s`:
+  # Returns a string representation of `self`, including <code>begin.to_s</code>
+  # and <code>end.to_s</code>:
   #
   #     (1..4).to_s  # => "1..4"
   #     (1...4).to_s # => "1...4"
@@ -1124,9 +1129,9 @@ class Range[out Elem] < Object
   # Returns `true` if and only if:
   #
   # *   `other` is a range.
-  # *   `other.begin.eql?(self.begin)`.
-  # *   `other.end.eql?(self.end)`.
-  # *   `other.exclude_end? == self.exclude_end?`.
+  # *   <code>other.begin.eql?(self.begin)</code>.
+  # *   <code>other.end.eql?(self.end)</code>.
+  # *   <code>other.exclude_end? == self.exclude_end?</code>.
   #
   # Otherwise returns `false`.
   #

data/core/rational.rbs

@@ -161,7 +161,7 @@ class Rational < Numeric
   #
   # Returns:
   #
-  # *   `-1`, if `self` is less than `other`.
+  # *   <code>-1</code>, if `self` is less than `other`.
   # *   `0`, if the two values are the same.
   # *   `1`, if `self` is greater than `other`.
   # *   `nil`, if the two values are incomparable.
@@ -216,7 +216,7 @@ class Rational < Numeric
   # `ndigits` decimal digits (default: 0).
   #
   # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
+  # <code>ndigits.abs</code> trailing zeros.
   #
   # Returns a rational when `ndigits` is positive, otherwise returns an integer.
   #
@@ -272,7 +272,7 @@ class Rational < Numeric
   # `ndigits` decimal digits (default: 0).
   #
   # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
+  # <code>ndigits.abs</code> trailing zeros.
   #
   # Returns a rational when `ndigits` is positive, otherwise returns an integer.
   #
@@ -392,7 +392,7 @@ class Rational < Numeric
   # decimal digits (default: 0).
   #
   # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
+  # <code>ndigits.abs</code> trailing zeros.
   #
   # Returns a rational when `ndigits` is positive, otherwise returns an integer.
   #
@@ -482,7 +482,7 @@ class Rational < Numeric
   # digits (default: 0).
   #
   # When the precision is negative, the returned value is an integer with at least
-  # `ndigits.abs` trailing zeros.
+  # <code>ndigits.abs</code> trailing zeros.
   #
   # Returns a rational when `ndigits` is positive, otherwise returns an integer.
   #