rbs 4.0.0.dev.4 → 4.0.0.dev.5

data/core/random.rbs

@@ -96,6 +96,23 @@ class Random < RBS::Unnamed::Random_Base
                | (Float | ::Range[Float] max) -> Float
                | [T < Numeric] (::Range[T]) -> T
 
+  # <!--
+  #   rdoc-file=random.c
+  #   - Random.seed -> integer
+  # -->
+  # Returns the seed value used to initialize the Ruby system PRNG. 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.
+  #
+  #     Random.seed      #=> 1234
+  #     prng1 = Random.new(Random.seed)
+  #     prng1.seed       #=> 1234
+  #     prng1.rand(100)  #=> 47
+  #     Random.seed      #=> 1234
+  #     Random.rand(100) #=> 47
+  #
+  def self.seed: () -> ::Integer
+
   # <!--
   #   rdoc-file=random.c
   #   - srand(number = Random.new_seed) -> old_seed

data/core/range.rbs

@@ -86,14 +86,14 @@
 #     end
 #     a # => [2, 4, 6, 8, 10]
 #
-# A range can be both beginless and endless.  For literal beginless, endless
+# A range can be both beginless and endless. For literal beginless, endless
 # ranges, at least the beginning or end of the range must be given as an
 # explicit nil value. It is recommended to use an explicit nil beginning and
-# implicit nil end, since that is what Ruby uses for Range#inspect:
+# end, since that is what Ruby uses for Range#inspect:
 #
-#     (nil..)    # => (nil..)
-#     (..nil)    # => (nil..)
-#     (nil..nil) # => (nil..)
+#     (nil..)    # => (nil..nil)
+#     (..nil)    # => (nil..nil)
+#     (nil..nil) # => (nil..nil)
 #
 # ## Ranges and Other Classes
 #
@@ -351,7 +351,7 @@ class Range[out Elem] < Object
   # -->
   # Returns an element from `self` selected by a binary search.
   #
-  # See [Binary Searching](rdoc-ref:bsearch.rdoc).
+  # See [Binary Searching](rdoc-ref:language/bsearch.rdoc).
   #
   def bsearch: () -> ::Enumerator[Elem, Elem?]
              | () { (Elem) -> (true | false) } -> Elem?
@@ -741,10 +741,7 @@ class Range[out Elem] < Object
   #
   # Related: Range#min, Range#minmax.
   #
-  def max: () -> Elem
-         | () { (Elem a, Elem b) -> Integer } -> Elem
-         | (Integer n) -> ::Array[Elem]
-         | (Integer n) { (Elem a, Elem b) -> Integer } -> ::Array[Elem]
+  def max: ...
 
   # <!--
   #   rdoc-file=range.c
@@ -826,10 +823,52 @@ class Range[out Elem] < Object
   #
   # Related: Range#max, Range#minmax.
   #
-  def min: () -> Elem
-         | () { (Elem a, Elem b) -> Integer } -> Elem
-         | (Integer n) -> ::Array[Elem]
-         | (Integer n) { (Elem a, Elem b) -> Integer } -> ::Array[Elem]
+  def min: ...
+
+  # <!--
+  #   rdoc-file=range.c
+  #   - minmax -> [object, 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.
+  #
+  # With no block given, returns the minimum and maximum values, using `#<=>` for
+  # comparison:
+  #
+  #     (1..4).minmax     # => [1, 4]
+  #     (1...4).minmax    # => [1, 3]
+  #     ('a'..'d').minmax # => ["a", "d"]
+  #     (-4..-1).minmax   # => [-4, -1]
+  #
+  # With a block given, the block must return an integer:
+  #
+  # *   Negative if `a` is smaller than `b`.
+  # *   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:
+  #
+  #     (1..4).minmax {|a, b| -(a <=> b) } # => [4, 1]
+  #
+  # Returns `[nil, nil]` if:
+  #
+  # *   The begin value of the range is larger than the end value:
+  #
+  #         (4..1).minmax                      # => [nil, nil]
+  #         (4..1).minmax {|a, b| -(a <=> b) } # => [nil, nil]
+  #
+  # *   The begin value of an exclusive range is equal to the end value:
+  #
+  #         (1...1).minmax                          # => [nil, nil]
+  #         (1...1).minmax  {|a, b| -(a <=> b) }    # => [nil, nil]
+  #
+  # Raises an exception if `self` is a beginless or an endless range.
+  #
+  # Related: Range#min, Range#max.
+  #
+  def minmax: ...
 
   # <!--
   #   rdoc-file=range.c
@@ -936,8 +975,43 @@ class Range[out Elem] < Object
   #
   # Related: Range#count.
   #
-  def size: () -> Integer?
-          | () -> Float?
+  def size: () -> (Integer | Float | nil)
+
+  # <!--
+  #   rdoc-file=range.c
+  #   - count -> integer
+  #   - count(object) -> integer
+  #   - count {|element| ... } -> integer
+  # -->
+  # Returns the count of elements, based on an argument or block criterion, if
+  # given.
+  #
+  # With no argument and no block given, returns the number of elements:
+  #
+  #     (1..4).count      # => 4
+  #     (1...4).count     # => 3
+  #     ('a'..'d').count  # => 4
+  #     ('a'...'d').count # => 3
+  #     (1..).count       # => Infinity
+  #     (..4).count       # => Infinity
+  #
+  # With argument `object`, returns the number of `object` found in `self`, which
+  # will usually be zero or one:
+  #
+  #     (1..4).count(2)   # => 1
+  #     (1..4).count(5)   # => 0
+  #     (1..4).count('a')  # => 0
+  #
+  # With a block given, calls the block with each element; returns the number of
+  # elements for which the block returns a truthy value:
+  #
+  #     (1..4).count {|element| element < 3 } # => 2
+  #
+  # Related: Range#size.
+  #
+  def count: () -> (Integer | Float)
+           | (untyped) -> Integer
+           | () { (Elem) -> boolish } -> Integer
 
   # <!--
   #   rdoc-file=range.c
@@ -1104,4 +1178,27 @@ class Range[out Elem] < Object
   # Related: Range#cover?.
   #
   def member?: (untyped obj) -> bool
+
+  # <!--
+  #   rdoc-file=range.c
+  #   - to_a -> array
+  # -->
+  # Returns an array containing the elements in `self`, if a finite collection;
+  # raises an exception otherwise.
+  #
+  #     (1..4).to_a     # => [1, 2, 3, 4]
+  #     (1...4).to_a    # => [1, 2, 3]
+  #     ('a'..'d').to_a # => ["a", "b", "c", "d"]
+  #
+  def to_a: ...
+
+  # <!-- rdoc-file=range.c -->
+  # Returns an array containing the elements in `self`, if a finite collection;
+  # raises an exception otherwise.
+  #
+  #     (1..4).to_a     # => [1, 2, 3, 4]
+  #     (1...4).to_a    # => [1, 2, 3]
+  #     ('a'..'d').to_a # => ["a", "b", "c", "d"]
+  #
+  alias entries to_a
 end

data/core/rational.rbs

@@ -53,15 +53,16 @@ class Rational < Numeric
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat * numeric  ->  numeric
+  #   - self * other -> numeric
   # -->
-  # Performs multiplication.
+  # Returns the numeric product of `self` and `other`:
   #
-  #     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
+  #     Rational(9, 8)  * 4               #=> (9/2)
+  #     Rational(20, 9) * 9.8             #=> 21.77777777777778
+  #     Rational(9, 8)  * Complex(1, 2)   # => ((9/8)+(9/4)*i)
+  #     Rational(2, 3)  * Rational(2, 3)  #=> (4/9)
+  #     Rational(900)   * Rational(1)     #=> (900/1)
+  #     Rational(-2, 9) * Rational(-9, 2) #=> (1/1)
   #
   def *: (Integer) -> Rational
        | (Rational) -> Rational
@@ -69,9 +70,9 @@ class Rational < Numeric
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat ** numeric  ->  numeric
+  #   - self ** exponent -> numeric
   # -->
-  # Performs exponentiation.
+  # Returns `self` raised to the power `exponent`:
   #
   #     Rational(2)    ** Rational(3)     #=> (8/1)
   #     Rational(10)   ** -2              #=> (1/100)
@@ -85,27 +86,35 @@ class Rational < Numeric
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat + numeric  ->  numeric
+  #   - self + other -> numeric
   # -->
-  # Performs addition.
+  # Returns the sum of `self` and `other`:
   #
-  #     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
+  #     Rational(2, 3) + 0  # => (2/3)
+  #     Rational(2, 3) + 1  # => (5/3)
+  #     Rational(2, 3) + -1 # => (-1/3)
+  #
+  #     Rational(2, 3) + Complex(1, 0)     # => ((5/3)+0i)
+  #
+  #     Rational(2, 3) + Rational(1, 1)     # => (5/3)
+  #     Rational(2, 3) + Rational(3, 2)     # => (13/6)
+  #     Rational(2, 3) + Rational(3.0, 2.0) # => (13/6)
+  #     Rational(2, 3) + Rational(3.1, 2.1) # => (30399297484750849/14186338826217063)
+  #
+  # For a computation involving Floats, the result may be inexact (see Float#+):
+  #
+  #     Rational(2, 3) + 1.0 # => 1.6666666666666665
+  #     Rational(2, 3) + Complex(1.0, 0.0) # => (1.6666666666666665+0.0i)
   #
   def +: (Float) -> Float
        | (Complex) -> Complex
        | (Numeric) -> Rational
 
-  def +@: () -> Rational
-
   # <!--
   #   rdoc-file=rational.c
-  #   - rat - numeric  ->  numeric
+  #   - self - other -> numeric
   # -->
-  # Performs subtraction.
+  # Returns the difference of `self` and `other`:
   #
   #     Rational(2, 3)  - Rational(2, 3)   #=> (0/1)
   #     Rational(900)   - Rational(1)      #=> (899/1)
@@ -119,18 +128,20 @@ class Rational < Numeric
 
   # <!--
   #   rdoc-file=rational.c
-  #   - -rat  ->  rational
+  #   - -self -> rational
   # -->
-  # Negates `rat`.
+  # Returns `self`, negated:
+  #
+  #     -(1/3r)   # => (-1/3)
+  #     -(-1/3r)  # => (1/3)
   #
   def -@: () -> Rational
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat / numeric     ->  numeric
-  #   - rat.quo(numeric)  ->  numeric
+  #   - self / other -> numeric
   # -->
-  # Performs division.
+  # Returns the quotient of `self` and `other`:
   #
   #     Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
   #     Rational(900)   / Rational(1)      #=> (900/1)
@@ -144,20 +155,29 @@ class Rational < Numeric
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rational <=> numeric  ->  -1, 0, +1, or nil
+  #   - self <=> other -> -1, 0, 1, or nil
   # -->
-  # Returns -1, 0, or +1 depending on whether `rational` is less than, equal to,
-  # or greater than `numeric`.
+  # Compares `self` and `other`.
+  #
+  # Returns:
+  #
+  # *   `-1`, 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.
   #
-  # `nil` is returned if the two values are incomparable.
+  # Examples:
   #
-  #     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(2, 3) <=> Rational(4, 3) # => -1
+  #     Rational(2, 1) <=> Rational(2, 1) # => 0
+  #     Rational(2, 1) <=> 2              # => 0
+  #     Rational(2, 1) <=> 2.0            # => 0
+  #     Rational(2, 1) <=> Complex(2, 0)  # => 0
+  #     Rational(4, 3) <=> Rational(2, 3) # => 1
+  #     Rational(4, 3) <=> :foo           # => nil
   #
-  #     Rational(1, 3) <=> "0.3"           #=> nil
+  # Class Rational includes module Comparable, each of whose methods uses
+  # Rational#<=> for comparison.
   #
   def <=>: (Integer | Rational) -> Integer
          | (untyped) -> Integer?
@@ -188,12 +208,6 @@ class Rational < Numeric
   #
   def abs: () -> Rational
 
-  def abs2: () -> Rational
-
-  def angle: () -> (Integer | Float)
-
-  alias arg angle
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.ceil([ndigits])  ->  integer or rational
@@ -222,10 +236,6 @@ class Rational < Numeric
 
   def coerce: (Numeric) -> [ Numeric, Numeric ]
 
-  def conj: () -> Rational
-
-  def conjugate: () -> Rational
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.denominator  ->  integer
@@ -239,15 +249,9 @@ class Rational < Numeric
   #
   def denominator: () -> Integer
 
-  def div: (Numeric) -> Integer
-
   def divmod: (Integer | Float | Rational) -> [ Integer, Rational ]
             | (Numeric) -> [ Numeric, Numeric ]
 
-  def dup: () -> self
-
-  def eql?: (untyped) -> bool
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.fdiv(numeric)  ->  float
@@ -260,8 +264,6 @@ class Rational < Numeric
   #
   def fdiv: (Numeric) -> Float
 
-  def finite?: () -> bool
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.floor([ndigits])  ->  integer or rational
@@ -295,14 +297,6 @@ class Rational < Numeric
   #
   def hash: () -> Integer
 
-  def i: () -> Complex
-
-  def imag: () -> Integer
-
-  def imaginary: () -> Integer
-
-  def infinite?: () -> Integer?
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.inspect  ->  string
@@ -315,8 +309,6 @@ class Rational < Numeric
   #
   def inspect: () -> String
 
-  def integer?: () -> bool
-
   # <!-- rdoc-file=rational.c -->
   # Returns the absolute value of `rat`.
   #
@@ -336,8 +328,6 @@ class Rational < Numeric
   #
   def negative?: () -> bool
 
-  def nonzero?: () -> self?
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.numerator  ->  integer
@@ -351,8 +341,6 @@ class Rational < Numeric
   #
   def numerator: () -> Integer
 
-  alias phase angle
-
   def polar: () -> [ Rational, Integer | Float ]
 
   # <!--
@@ -364,7 +352,7 @@ class Rational < Numeric
   def positive?: () -> bool
 
   # <!-- rdoc-file=rational.c -->
-  # Performs division.
+  # Returns the quotient of `self` and `other`:
   #
   #     Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
   #     Rational(900)   / Rational(1)      #=> (900/1)
@@ -391,14 +379,8 @@ class Rational < Numeric
   #
   def rationalize: (?Numeric eps) -> Rational
 
-  def real: () -> Rational
-
-  def real?: () -> true
-
   def rect: () -> [ Rational, Numeric ]
 
-  alias rectangular rect
-
   def remainder: (Float) -> Float
                | (Numeric) -> Rational
 
@@ -440,13 +422,6 @@ class Rational < Numeric
   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
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.to_f  ->  float
@@ -476,8 +451,6 @@ class Rational < Numeric
   #
   def to_i: () -> Integer
 
-  alias to_int to_i
-
   # <!--
   #   rdoc-file=rational.c
   #   - rat.to_r  ->  self
@@ -526,6 +499,4 @@ class Rational < Numeric
   #
   def truncate: () -> Integer
               | (Integer ndigits) -> (Integer | Rational)
-
-  def zero?: () -> bool
 end

data/core/rbs/unnamed/argf.rbs

@@ -93,7 +93,7 @@ module RBS
     # *   File `t.rb`:
     #
     #         p "ARGV: #{ARGV}"
-    #         p "Line: #{ARGF.read}" # Read everything from all specified streams.
+    #         p "Read: #{ARGF.read}" # Read everything from all specified streams.
     #
     # *   Command and output:
     #
@@ -836,7 +836,7 @@ module RBS
       # Formats and writes `objects` to the stream.
       #
       # For details on `format_string`, see [Format
-      # Specifications](rdoc-ref:format_specifications.rdoc).
+      # Specifications](rdoc-ref:language/format_specifications.rdoc).
       #
       %a{annotate:rdoc:copy:ARGF#printf}
       def printf: (String format_string, *untyped args) -> nil

data/core/rbs/unnamed/env_class.rbs

@@ -140,7 +140,7 @@ module RBS
     #
     # *   ::assoc: Returns a 2-element array containing the name and value of the
     #     named environment variable if it exists:
-    # *   ::clone: Returns `ENV` (and issues a warning).
+    # *   ::clone: Raises an exception.
     # *   ::except: Returns a hash of all name/value pairs except those given.
     # *   ::fetch: Returns the value for the given name.
     # *   ::inspect: Returns the contents of `ENV` as a string.

data/core/rbs/unnamed/random.rbs

@@ -31,9 +31,11 @@ module RBS
       #     prng.rand(100)       # => 42
       #
       # When `max` is a Float, `rand` returns a random floating point number between
-      # 0.0 and `max`, including 0.0 and excluding `max`.
+      # 0.0 and `max`, including 0.0 and excluding `max`. Note that it behaves
+      # differently from Kernel.rand.
       #
-      #     prng.rand(1.5)       # => 1.4600282860034115
+      #     prng.rand(1.5)  # => 1.4600282860034115
+      #     rand(1.5)       # => 0
       #
       # When `range` is a Range, `rand` returns a random number where
       # `range.member?(number) == true`.
@@ -146,56 +148,6 @@ module RBS
     #
     %a{annotate:rdoc:copy:Random::Formatter}
     module Random_Formatter
-      # <!--
-      #   rdoc-file=lib/random/formatter.rb
-      #   - base64(n=nil)
-      # -->
-      # Generate a random base64 string.
-      #
-      # The argument *n* specifies the length, in bytes, of the random number to be
-      # generated. The length of the result string is about 4/3 of *n*.
-      #
-      # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
-      # future.
-      #
-      # The result may contain A-Z, a-z, 0-9, "+", "/" and "=".
-      #
-      #     require 'random/formatter'
-      #
-      #     Random.base64 #=> "/2BuBuLf3+WfSKyQbRcc/A=="
-      #     # or
-      #     prng = Random.new
-      #     prng.base64 #=> "6BbW0pxO0YENxn38HMUbcQ=="
-      #
-      # See RFC 3548 for the definition of base64.
-      #
-      %a{annotate:rdoc:copy:Random::Formatter#base64}
-      def base64: (?Integer? n) -> String
-
-      # <!--
-      #   rdoc-file=lib/random/formatter.rb
-      #   - hex(n=nil)
-      # -->
-      # Generate a random hexadecimal string.
-      #
-      # The argument *n* specifies the length, in bytes, of the random number to be
-      # generated. The length of the resulting hexadecimal string is twice of *n*.
-      #
-      # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
-      # future.
-      #
-      # The result may contain 0-9 and a-f.
-      #
-      #     require 'random/formatter'
-      #
-      #     Random.hex #=> "eb693ec8252cd630102fd0d0fb7c3485"
-      #     # or
-      #     prng = Random.new
-      #     prng.hex #=> "91dc3bfb4de5b11d029d376634589b61"
-      #
-      %a{annotate:rdoc:copy:Random::Formatter#hex}
-      def hex: (?Integer? n) -> String
-
       # <!-- rdoc-file=random.c -->
       # Generates formatted random number from raw random bytes. See Random#rand.
       #
@@ -208,9 +160,6 @@ module RBS
               | (::Range[Integer] n) -> Integer
               | (::Range[Numeric] n) -> Numeric
 
-      %a{annotate:rdoc:copy:Random::Formatter#random_byte}
-      def random_bytes: (?Integer? n) -> String
-
       # <!--
       #   rdoc-file=random.c
       #   - prng.random_number        -> float
@@ -230,64 +179,6 @@ module RBS
                        | (?::Range[Float]? n) -> Float
                        | (?::Range[Integer]? n) -> Integer
                        | (?::Range[Numeric]? n) -> Numeric
-
-      # <!--
-      #   rdoc-file=lib/random/formatter.rb
-      #   - urlsafe_base64(n=nil, padding=false)
-      # -->
-      # Generate a random URL-safe base64 string.
-      #
-      # The argument *n* specifies the length, in bytes, of the random number to be
-      # generated. The length of the result string is about 4/3 of *n*.
-      #
-      # If *n* is not specified or is nil, 16 is assumed. It may be larger in the
-      # future.
-      #
-      # The boolean argument *padding* specifies the padding. If it is false or nil,
-      # padding is not generated. Otherwise padding is generated. By default, padding
-      # is not generated because "=" may be used as a URL delimiter.
-      #
-      # The result may contain A-Z, a-z, 0-9, "-" and "_". "=" is also used if
-      # *padding* is true.
-      #
-      #     require 'random/formatter'
-      #
-      #     Random.urlsafe_base64 #=> "b4GOKm4pOYU_-BOXcrUGDg"
-      #     # or
-      #     prng = Random.new
-      #     prng.urlsafe_base64 #=> "UZLdOkzop70Ddx-IJR0ABg"
-      #
-      #     prng.urlsafe_base64(nil, true) #=> "i0XQ-7gglIsHGV2_BNPrdQ=="
-      #     prng.urlsafe_base64(nil, true) #=> "-M8rLhr7JEpJlqFGUMmOxg=="
-      #
-      # See RFC 3548 for the definition of URL-safe base64.
-      #
-      %a{annotate:rdoc:copy:Random::Formatter#urlsafe_base64}
-      def urlsafe_base64: (?Integer? n, ?boolish padding) -> String
-
-      # <!--
-      #   rdoc-file=lib/random/formatter.rb
-      #   - uuid()
-      # -->
-      # Generate a random v4 UUID (Universally Unique IDentifier).
-      #
-      #     require 'random/formatter'
-      #
-      #     Random.uuid #=> "2d931510-d99f-494a-8c67-87feb05e1594"
-      #     Random.uuid #=> "bad85eb9-0713-4da7-8d36-07a8e4b00eab"
-      #     # or
-      #     prng = Random.new
-      #     prng.uuid #=> "62936e70-1815-439b-bf89-8492855a7e6b"
-      #
-      # The version 4 UUID is purely random (except the version). It doesn't contain
-      # meaningful information such as MAC addresses, timestamps, etc.
-      #
-      # The result contains 122 random bits (15.25 random bytes).
-      #
-      # See [RFC9562](https://www.rfc-editor.org/rfc/rfc9562) for details of UUIDv4.
-      #
-      %a{annotate:rdoc:copy:Random::Formatter#uuid}
-      def uuid: () -> String
     end
   end
 end