rbs 3.10.0.pre.2 → 3.10.1

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,15 +86,25 @@ 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
@@ -103,9 +114,9 @@ class Rational < Numeric
 
   # <!--
   #   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 +130,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 +157,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?
@@ -364,7 +386,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)

data/core/rbs/unnamed/argf.rbs

@@ -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/regexp.rbs

@@ -39,7 +39,7 @@
 #     most such methods accept an argument that may be either a string or the
 #     (much more powerful) regexp.
 #
-#     See [Regexp Methods](rdoc-ref:regexp/methods.rdoc).
+#     See [Regexp Methods](rdoc-ref:language/regexp/methods.rdoc).
 #
 # ## Regexp Objects
 #
@@ -821,8 +821,8 @@
 #     /\P{Alpha}/.match('1') # => #<MatchData "1">
 #     /\P{Alpha}/.match('a') # => nil
 #
-# See [Unicode Properties](rdoc-ref:regexp/unicode_properties.rdoc) for regexps
-# based on the numerous properties.
+# See [Unicode Properties](rdoc-ref:language/regexp/unicode_properties.rdoc) for
+# regexps based on the numerous properties.
 #
 # Some commonly-used properties correspond to POSIX bracket expressions:
 #

data/core/ruby.rbs

@@ -0,0 +1,53 @@
+# <!-- rdoc-file=version.c -->
+# The [Ruby](rdoc-ref:Ruby) module that contains portable information among
+# implementations.
+#
+# The constants defined here are aliased in the toplevel with `RUBY_` prefix.
+#
+module Ruby
+  # <!-- rdoc-file=version.c -->
+  # The copyright string for ruby
+  #
+  COPYRIGHT: ::String
+
+  # <!-- rdoc-file=version.c -->
+  # The full ruby version string, like `ruby -v` prints
+  #
+  DESCRIPTION: ::String
+
+  # <!-- rdoc-file=version.c -->
+  # The engine or interpreter this ruby uses.
+  #
+  ENGINE: ::String
+
+  # <!-- rdoc-file=version.c -->
+  # The version of the engine or interpreter this ruby uses.
+  #
+  ENGINE_VERSION: ::String
+
+  # <!-- rdoc-file=version.c -->
+  # The patchlevel for this ruby.  If this is a development build of ruby the
+  # patchlevel will be -1
+  #
+  PATCHLEVEL: ::Integer
+
+  # <!-- rdoc-file=version.c -->
+  # The platform for this ruby
+  #
+  PLATFORM: ::String
+
+  # <!-- rdoc-file=version.c -->
+  # The date this ruby was released
+  #
+  RELEASE_DATE: ::String
+
+  # <!-- rdoc-file=version.c -->
+  # The GIT commit hash for this ruby.
+  #
+  REVISION: ::String
+
+  # <!-- rdoc-file=version.c -->
+  # The running version of ruby
+  #
+  VERSION: ::String
+end

data/core/rubygems/version.rbs

@@ -180,7 +180,6 @@ module Gem
     #
     #     ver1 = Version.create('1.3.17')   # -> (Version object)
     #     ver2 = Version.create(ver1)       # -> (ver1)
-    #     ver3 = Version.create(nil)        # -> nil
     #
     def self.create: (_ToS | Version input) -> instance
                    | (nil input) -> nil
@@ -199,8 +198,8 @@ module Gem
     #   - <=>(other)
     # -->
     # Compares this version with `other` returning -1, 0, or 1 if the other version
-    # is larger, the same, or smaller than this one. Attempts to compare to
-    # something that's not a `Gem::Version` or a valid version String return `nil`.
+    # is larger, the same, or smaller than this one. `other` must be an instance of
+    # Gem::Version, comparing with other types may raise an exception.
     #
     def <=>: (untyped other) -> Integer?
 

data/core/set.rbs

@@ -1,16 +1,9 @@
 # <!-- rdoc-file=set.c -->
-# Copyright (c) 2002-2024 Akinori MUSHA <knu@iDaemons.org>
-#
-# Documentation by Akinori MUSHA and Gavin Sinclair.
-#
-# All rights reserved.  You can redistribute and/or modify it under the same
-# terms as Ruby.
-#
 # The Set class implements a collection of unordered values with no duplicates.
 # It is a hybrid of Array's intuitive inter-operation facilities and Hash's fast
 # lookup.
 #
-# Set is easy to use with Enumerable objects (implementing `each`). Most of the
+# Set is easy to use with Enumerable objects (implementing #each). Most of the
 # initializer methods and binary operators accept generic Enumerable objects
 # besides sets and arrays.  An Enumerable object can be converted to Set using
 # the `to_set` method.
@@ -36,11 +29,11 @@
 #
 # ## Example
 #
-#     s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
-#     s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
+#     s1 = Set[1, 2]                        #=> Set[1, 2]
+#     s2 = [1, 2].to_set                    #=> Set[1, 2]
 #     s1 == s2                              #=> true
-#     s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
-#     s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
+#     s1.add("foo")                         #=> Set[1, 2, "foo"]
+#     s1.merge([2, 6])                      #=> Set[1, 2, "foo", 6]
 #     s1.subset?(s2)                        #=> false
 #     s2.subset?(s1)                        #=> true
 #
@@ -48,9 +41,39 @@
 #
 # *   Akinori MUSHA <knu@iDaemons.org> (current maintainer)
 #
-# ## What's Here
+# ## Inheriting from Set
+#
+# Before Ruby 4.0 (released December 2025), Set had a different, less efficient
+# implementation. It was reimplemented in C, and the behavior of some of the
+# core methods were adjusted.
+#
+# To keep backward compatibility, when a class is inherited from Set, additional
+# module `Set::SubclassCompatible` is included, which makes the inherited class
+# behavior, as well as internal method names, closer to what it was before Ruby
+# 4.0.
+#
+# It can be easily seen, for example, in the #inspect method behavior:
+#
+#     p Set[1, 2, 3]
+#     # prints "Set[1, 2, 3]"
+#
+#     class MySet < Set
+#     end
+#     p MySet[1, 2, 3]
+#     # prints "#<MySet: {1, 2, 3}>", like it was in Ruby 3.4
+#
+# For new code, if backward compatibility is not necessary, it is recommended to
+# instead inherit from `Set::CoreSet`, which avoids including the
+# "compatibility" layer:
+#
+#     class MyCoreSet < Set::CoreSet
+#     end
+#     p MyCoreSet[1, 2, 3]
+#     # prints "MyCoreSet[1, 2, 3]"
+#
+# ## Set's methods
 #
-#     First, what's elsewhere. \Class \Set:
+# First, what's elsewhere. Class Set:
 #
 # *   Inherits from [class Object](rdoc-ref:Object@What-27s+Here).
 # *   Includes [module Enumerable](rdoc-ref:Enumerable@What-27s+Here), which
@@ -61,16 +84,15 @@
 #
 # Here, class Set provides methods that are useful for:
 #
-# *   [Creating an Array](rdoc-ref:Array@Methods+for+Creating+an+Array)
 # *   [Creating a Set](rdoc-ref:Set@Methods+for+Creating+a+Set)
 # *   [Set Operations](rdoc-ref:Set@Methods+for+Set+Operations)
-# *   [Comparing](rdoc-ref:Array@Methods+for+Comparing)
-# *   [Querying](rdoc-ref:Array@Methods+for+Querying)
-# *   [Assigning](rdoc-ref:Array@Methods+for+Assigning)
-# *   [Deleting](rdoc-ref:Array@Methods+for+Deleting)
-# *   [Converting](rdoc-ref:Array@Methods+for+Converting)
-# *   [Iterating](rdoc-ref:Array@Methods+for+Iterating)
-# *   [And more....](rdoc-ref:Array@Other+Methods)
+# *   [Comparing](rdoc-ref:Set@Methods+for+Comparing)
+# *   [Querying](rdoc-ref:Set@Methods+for+Querying)
+# *   [Assigning](rdoc-ref:Set@Methods+for+Assigning)
+# *   [Deleting](rdoc-ref:Set@Methods+for+Deleting)
+# *   [Converting](rdoc-ref:Set@Methods+for+Converting)
+# *   [Iterating](rdoc-ref:Set@Methods+for+Iterating)
+# *   [And more....](rdoc-ref:Set@Other+Methods)
 #
 # ### Methods for Creating a Set
 #
@@ -183,11 +205,11 @@ class Set[unchecked out A]
   #
   # If a block is given, the elements of enum are preprocessed by the given block.
   #
-  #     Set.new([1, 2])                       #=> #<Set: {1, 2}>
-  #     Set.new([1, 2, 1])                    #=> #<Set: {1, 2}>
-  #     Set.new([1, 'c', :s])                 #=> #<Set: {1, "c", :s}>
-  #     Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
-  #     Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>
+  #     Set.new([1, 2])                       #=> Set[1, 2]
+  #     Set.new([1, 2, 1])                    #=> Set[1, 2]
+  #     Set.new([1, 'c', :s])                 #=> Set[1, "c", :s]
+  #     Set.new(1..5)                         #=> Set[1, 2, 3, 4, 5]
+  #     Set.new([1, 2, 3]) { |x| x * x }      #=> Set[1, 4, 9]
   #
   def initialize: (_Each[A]) -> untyped
                 | [X] (_Each[X]) { (X) -> A } -> untyped
@@ -208,8 +230,8 @@ class Set[unchecked out A]
   # Returns a new set containing elements common to the set and the given
   # enumerable object.
   #
-  #     Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
-  #     Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>
+  #     Set[1, 3, 5] & Set[3, 2, 1]             #=> Set[3, 1]
+  #     Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> Set["a", "b"]
   #
   def &: (_Each[A]) -> self
 
@@ -217,8 +239,8 @@ class Set[unchecked out A]
   # Returns a new set containing elements common to the set and the given
   # enumerable object.
   #
-  #     Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
-  #     Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>
+  #     Set[1, 3, 5] & Set[3, 2, 1]             #=> Set[3, 1]
+  #     Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> Set["a", "b"]
   #
   alias intersection &
 
@@ -229,8 +251,8 @@ class Set[unchecked out A]
   # Returns a new set built by merging the set and the elements of the given
   # enumerable object.
   #
-  #     Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
-  #     Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>
+  #     Set[1, 2, 3] | Set[2, 4, 5]         #=> Set[1, 2, 3, 4, 5]
+  #     Set[1, 5, 'z'] | (1..6)             #=> Set[1, 5, "z", 2, 3, 4, 6]
   #
   def |: (_Each[A]) -> self
 
@@ -238,8 +260,8 @@ class Set[unchecked out A]
   # Returns a new set built by merging the set and the elements of the given
   # enumerable object.
   #
-  #     Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
-  #     Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>
+  #     Set[1, 2, 3] | Set[2, 4, 5]         #=> Set[1, 2, 3, 4, 5]
+  #     Set[1, 5, 'z'] | (1..6)             #=> Set[1, 5, "z", 2, 3, 4, 6]
   #
   alias union |
 
@@ -247,8 +269,8 @@ class Set[unchecked out A]
   # Returns a new set built by merging the set and the elements of the given
   # enumerable object.
   #
-  #     Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
-  #     Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>
+  #     Set[1, 2, 3] | Set[2, 4, 5]         #=> Set[1, 2, 3, 4, 5]
+  #     Set[1, 5, 'z'] | (1..6)             #=> Set[1, 5, "z", 2, 3, 4, 6]
   #
   alias + |
 
@@ -259,8 +281,8 @@ class Set[unchecked out A]
   # Returns a new set built by duplicating the set, removing every element that
   # appears in the given enumerable object.
   #
-  #     Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
-  #     Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>
+  #     Set[1, 3, 5] - Set[1, 5]                #=> Set[3]
+  #     Set['a', 'b', 'z'] - ['a', 'c']         #=> Set["b", "z"]
   #
   def -: (_Each[A]) -> self
 
@@ -268,8 +290,8 @@ class Set[unchecked out A]
   # Returns a new set built by duplicating the set, removing every element that
   # appears in the given enumerable object.
   #
-  #     Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
-  #     Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>
+  #     Set[1, 3, 5] - Set[1, 5]                #=> Set[3]
+  #     Set['a', 'b', 'z'] - ['a', 'c']         #=> Set["b", "z"]
   #
   alias difference -
 
@@ -277,22 +299,22 @@ class Set[unchecked out A]
   #   rdoc-file=set.c
   #   - add(obj) -> self
   # -->
-  # Adds the given object to the set and returns self.  Use `merge` to add many
+  # Adds the given object to the set and returns self. Use Set#merge to add many
   # elements at once.
   #
-  #     Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
-  #     Set[1, 2].add([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
-  #     Set[1, 2].add(2)                    #=> #<Set: {1, 2}>
+  #     Set[1, 2].add(3)                    #=> Set[1, 2, 3]
+  #     Set[1, 2].add([3, 4])               #=> Set[1, 2, [3, 4]]
+  #     Set[1, 2].add(2)                    #=> Set[1, 2]
   #
   def add: (A) -> self
 
   # <!-- rdoc-file=set.c -->
-  # Adds the given object to the set and returns self.  Use `merge` to add many
+  # Adds the given object to the set and returns self. Use Set#merge to add many
   # elements at once.
   #
-  #     Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
-  #     Set[1, 2].add([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
-  #     Set[1, 2].add(2)                    #=> #<Set: {1, 2}>
+  #     Set[1, 2].add(3)                    #=> Set[1, 2, 3]
+  #     Set[1, 2].add([3, 4])               #=> Set[1, 2, [3, 4]]
+  #     Set[1, 2].add(2)                    #=> Set[1, 2]
   #
   alias << add
 
@@ -303,8 +325,8 @@ class Set[unchecked out A]
   # Adds the given object to the set and returns self. If the object is already in
   # the set, returns nil.
   #
-  #     Set[1, 2].add?(3)                    #=> #<Set: {1, 2, 3}>
-  #     Set[1, 2].add?([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
+  #     Set[1, 2].add?(3)                    #=> Set[1, 2, 3]
+  #     Set[1, 2].add?([3, 4])               #=> Set[1, 2, [3, 4]]
   #     Set[1, 2].add?(2)                    #=> nil
   #
   def add?: (A) -> self?
@@ -366,8 +388,8 @@ class Set[unchecked out A]
   # enumerable object.  `(set ^ enum)` is equivalent to `((set | enum) - (set &
   # enum))`.
   #
-  #     Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
-  #     Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>
+  #     Set[1, 2] ^ Set[2, 3]                   #=> Set[3, 1]
+  #     Set[1, 'b', 'c'] ^ ['b', 'd']           #=> Set["d", 1, "c"]
   #
   def ^: (_Each[A]) -> self
 
@@ -382,9 +404,9 @@ class Set[unchecked out A]
   #
   #     files = Set.new(Dir.glob("*.rb"))
   #     hash = files.classify { |f| File.mtime(f).year }
-  #     hash       #=> {2000 => #<Set: {"a.rb", "b.rb"}>,
-  #                #    2001 => #<Set: {"c.rb", "d.rb", "e.rb"}>,
-  #                #    2002 => #<Set: {"f.rb"}>}
+  #     hash       #=> {2000 => Set["a.rb", "b.rb"],
+  #                #    2001 => Set["c.rb", "d.rb", "e.rb"],
+  #                #    2002 => Set["f.rb"]}
   #
   # Returns an enumerator if no block is given.
   #
@@ -396,9 +418,9 @@ class Set[unchecked out A]
   # -->
   # Removes all elements and returns self.
   #
-  #     set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
-  #     set.clear                         #=> #<Set: {}>
-  #     set                               #=> #<Set: {}>
+  #     set = Set[1, 'c', :s]             #=> Set[1, "c", :s]
+  #     set.clear                         #=> Set[]
+  #     set                               #=> Set[]
   #
   def clear: () -> self
 
@@ -502,10 +524,10 @@ class Set[unchecked out A]
   #
   #     numbers = Set[1, 3, 4, 6, 9, 10, 11]
   #     set = numbers.divide { |i,j| (i - j).abs == 1 }
-  #     set        #=> #<Set: {#<Set: {1}>,
-  #                #           #<Set: {3, 4}>,
-  #                #           #<Set: {6}>}>
-  #                #           #<Set: {9, 10, 11}>,
+  #     set        #=> Set[Set[1],
+  #                #       Set[3, 4],
+  #                #       Set[6],
+  #                #       Set[9, 10, 11]]
   #
   # Returns an enumerator if no block is given.
   #
@@ -654,9 +676,9 @@ class Set[unchecked out A]
   # Replaces the contents of the set with the contents of the given enumerable
   # object and returns self.
   #
-  #     set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
-  #     set.replace([1, 2])               #=> #<Set: {1, 2}>
-  #     set                               #=> #<Set: {1, 2}>
+  #     set = Set[1, 'c', :s]             #=> Set[1, "c", :s]
+  #     set.replace([1, 2])               #=> Set[1, 2]
+  #     set                               #=> Set[1, 2]
   #
   def replace: (_Each[A]) -> self
 

data/core/signal.rbs

@@ -65,26 +65,36 @@ module Signal
 
   # <!--
   #   rdoc-file=signal.c
-  #   - Signal.trap( signal, command ) -> obj
-  #   - Signal.trap( signal ) {| | block } -> obj
+  #   - Signal.trap(signal, command) -> obj
+  #   - Signal.trap(signal) { ... } -> obj
   # -->
-  # Specifies the handling of signals. The first parameter is a signal name (a
-  # string such as ``SIGALRM'', ``SIGUSR1'', and so on) or a signal number. The
-  # characters ``SIG'' may be omitted from the signal name. The command or block
-  # specifies code to be run when the signal is raised. If the command is the
-  # string ``IGNORE'' or ``SIG_IGN'', the signal will be ignored. If the command
-  # is ``DEFAULT'' or ``SIG_DFL'', the Ruby's default handler will be invoked. If
-  # the command is ``EXIT'', the script will be terminated by the signal. If the
-  # command is ``SYSTEM_DEFAULT'', the operating system's default handler will be
-  # invoked. Otherwise, the given command or block will be run. The special signal
-  # name ``EXIT'' or signal number zero will be invoked just prior to program
-  # termination. trap returns the previous handler for the given signal.
+  # Specifies the handling of signals. Returns the previous handler for the given
+  # signal.
+  #
+  # Argument `signal` is a signal name (a string or symbol such as `SIGALRM` or
+  # `SIGUSR1`) or an integer signal number. When `signal` is a string or symbol,
+  # the leading characters `SIG` may be omitted.
+  #
+  # Argument `command` or block provided specifies code to be run when the signal
+  # is raised.
+  #
+  # Argument `command` may also be a string or symbol with the following special
+  # values:
+  #
+  # *   `IGNORE`, `SIG_IGN`: the signal will be ignored.
+  # *   `DEFAULT`, `SIG_DFL`: Ruby's default handler will be invoked.
+  # *   `EXIT`: the process will be terminated by the signal.
+  # *   `SYSTEM_DEFAULT`: the operating system's default handler will be invoked.
+  #
+  # The special signal name `EXIT` or signal number zero will be invoked just
+  # prior to program termination:
   #
   #     Signal.trap(0, proc { puts "Terminating: #{$$}" })
   #     Signal.trap("CLD")  { puts "Child died" }
   #     fork && Process.wait
   #
-  # *produces:*
+  # Outputs:
+  #
   #     Terminating: 27461
   #     Child died
   #     Terminating: 27460