rbs 3.10.0 → 3.10.1

data/core/method.rbs

@@ -126,7 +126,9 @@ class Method
 
   # <!--
   #   rdoc-file=proc.c
-  #   - meth.call(args, ...)    -> obj
+  #   - meth.call(args, ...) -> obj
+  #   - meth[args, ...] -> obj
+  #   - method === obj -> result_of_method
   # -->
   # Invokes the *meth* with the specified arguments, returning the method's return
   # value.
@@ -135,23 +137,32 @@ class Method
   #     m.call(3)    #=> 15
   #     m.call(20)   #=> 32
   #
+  # Using Method#=== allows a method object to be the target of a `when` clause in
+  # a case statement.
+  #
+  #     require 'prime'
+  #
+  #     case 1373
+  #     when Prime.method(:prime?)
+  #       # ...
+  #     end
+  #
   def call: (?) -> untyped
 
   # <!--
   #   rdoc-file=proc.c
-  #   - meth << g -> a_proc
+  #   - self << g -> a_proc
   # -->
-  # Returns a proc that is the composition of this method and the given *g*. The
-  # returned proc takes a variable number of arguments, calls *g* with them then
-  # calls this method with the result.
+  # Returns a proc that is the composition of the given `g` and this method.
   #
-  #     def f(x)
-  #       x * x
-  #     end
+  # The returned proc takes a variable number of arguments. It first calls `g`
+  # with the arguments, then calls `self` with the return value of `g`.
+  #
+  #     def f(ary) = ary << 'in f'
   #
   #     f = self.method(:f)
-  #     g = proc {|x| x + x }
-  #     p (f << g).call(2) #=> 16
+  #     g = proc { |ary| ary << 'in proc' }
+  #     (f << g).call([]) # => ["in proc", "in f"]
   #
   def <<: (Proc::_Callable g) -> Proc
 
@@ -163,23 +174,32 @@ class Method
   #     m.call(3)    #=> 15
   #     m.call(20)   #=> 32
   #
+  # Using Method#=== allows a method object to be the target of a `when` clause in
+  # a case statement.
+  #
+  #     require 'prime'
+  #
+  #     case 1373
+  #     when Prime.method(:prime?)
+  #       # ...
+  #     end
+  #
   alias === call
 
   # <!--
   #   rdoc-file=proc.c
-  #   - meth >> g -> a_proc
+  #   - self >> g -> a_proc
   # -->
-  # Returns a proc that is the composition of this method and the given *g*. The
-  # returned proc takes a variable number of arguments, calls this method with
-  # them then calls *g* with the result.
+  # Returns a proc that is the composition of this method and the given `g`.
   #
-  #     def f(x)
-  #       x * x
-  #     end
+  # The returned proc takes a variable number of arguments. It first calls `self`
+  # with the arguments, then calls `g` with the return value of `self`.
+  #
+  #     def f(ary) = ary << 'in f'
   #
   #     f = self.method(:f)
-  #     g = proc {|x| x + x }
-  #     p (f >> g).call(2) #=> 8
+  #     g = proc { |ary| ary << 'in proc' }
+  #     (f >> g).call([]) # => ["in f", "in proc"]
   #
   def >>: (Proc::_Callable g) -> Proc
 
@@ -191,6 +211,16 @@ class Method
   #     m.call(3)    #=> 15
   #     m.call(20)   #=> 32
   #
+  # Using Method#=== allows a method object to be the target of a `when` clause in
+  # a case statement.
+  #
+  #     require 'prime'
+  #
+  #     case 1373
+  #     when Prime.method(:prime?)
+  #       # ...
+  #     end
+  #
   alias [] call
 
   # <!--

data/core/module.rbs

@@ -114,12 +114,15 @@ class Module < Object
 
   # <!--
   #   rdoc-file=object.c
-  #   - mod < other   ->  true, false, or nil
+  #   - self < other -> true, false, or nil
   # -->
-  # Returns true if *mod* is a subclass of *other*. Returns `false` if *mod* is
-  # the same as *other* or *mod* is an ancestor of *other*. Returns `nil` if
-  # there's no relationship between the two. (Think of the relationship in terms
-  # of the class definition: "class A < B" implies "A < B".)
+  # Returns whether `self` is a subclass of `other`, or `nil` if there is no
+  # relationship between the two:
+  #
+  #     Float < Numeric # => true
+  #     Numeric < Float # => false
+  #     Float < Float   # => false
+  #     Float < Hash    # => nil
   #
   def <: (Module other) -> bool?
 
@@ -135,13 +138,15 @@ class Module < Object
 
   # <!--
   #   rdoc-file=object.c
-  #   - self <=> object -> -1, 0, +1, or nil
+  #   - self <=> other -> -1, 0, 1, or nil
   # -->
+  # Compares `self` and `other`.
+  #
   # Returns:
   #
-  # *   `-1`, if `self` includes `object`, if or `self` is a subclass of `object`.
-  # *   `0`, if `self` and `object` are the same.
-  # *   `1`, if `object` includes `self`, or if `object` is a subclass of `self`.
+  # *   `-1`, if `self` includes `other`, if or `self` is a subclass of `other`.
+  # *   `0`, if `self` and `other` are the same.
+  # *   `1`, if `other` includes `self`, or if `other` is a subclass of `self`.
   # *   `nil`, if none of the above is true.
   #
   # Examples:
@@ -152,8 +157,10 @@ class Module < Object
   #         Enumerable <=> Array      # =>  1
   #     # Class File is a subclass of class IO.
   #               File <=> IO         # => -1
-  #                 IO <=> File       # =>  1
   #               File <=> File       # =>  0
+  #                 IO <=> File       # =>  1
+  #     # Class File has no relationship to class String.
+  #               File <=> String     # => nil
   #
   def <=>: (untyped other) -> Integer?
 
@@ -1649,7 +1656,7 @@ class Module < Object
   #     m.name #=> nil
   #
   #     c = Class.new
-  #     c.set_temporary_name("MyClass(with description)")
+  #     c.set_temporary_name("MyClass(with description)") # => MyClass(with description)
   #
   #     c.new # => #<MyClass(with description):0x0....>
   #

data/core/numeric.rbs

@@ -220,7 +220,15 @@ class Numeric
   #   rdoc-file=numeric.c
   #   - self <=> other -> zero or nil
   # -->
-  # Returns zero if `self` is the same as `other`, `nil` otherwise.
+  # Compares `self` and `other`.
+  #
+  # Returns:
+  #
+  # *   Zero, if `self` is the same as `other`.
+  # *   `nil`, otherwise.
+  #
+  # Class Numeric includes module Comparable, each of whose methods uses
+  # Numeric#<=> for comparison.
   #
   # No subclass in the Ruby Core or Standard Library uses this implementation.
   #

data/core/pathname.rbs

@@ -670,28 +670,6 @@ class Pathname
   #
   def file?: () -> bool
 
-  # <!--
-  #   rdoc-file=lib/pathname.rb
-  #   - find(ignore_error: true) { |pathname| ... }
-  # -->
-  # Iterates over the directory tree in a depth first manner, yielding a Pathname
-  # for each file under "this" directory.
-  #
-  # Note that you need to require 'pathname' to use this method.
-  #
-  # Returns an Enumerator if no block is given.
-  #
-  # Since it is implemented by the standard library module Find, Find.prune can be
-  # used to control the traversal.
-  #
-  # If `self` is `.`, yielded pathnames begin with a filename in the current
-  # directory, not `./`.
-  #
-  # See Find.find
-  #
-  def find: (?ignore_error: boolish) { (Pathname) -> untyped } -> nil
-          | (?ignore_error: boolish) -> Enumerator[Pathname, nil]
-
   # <!--
   #   rdoc-file=pathname_builtin.rb
   #   - fnmatch(pattern, ...)
@@ -1017,18 +995,6 @@ class Pathname
   #
   def rmdir: () -> 0
 
-  # <!--
-  #   rdoc-file=lib/pathname.rb
-  #   - rmtree(noop: nil, verbose: nil, secure: nil)
-  # -->
-  # Recursively deletes a directory, including all directories beneath it.
-  #
-  # Note that you need to require 'pathname' to use this method.
-  #
-  # See FileUtils.rm_rf
-  #
-  def rmtree: () -> self
-
   # <!--
   #   rdoc-file=pathname_builtin.rb
   #   - root?()

data/core/proc.rbs

@@ -380,9 +380,9 @@ class Proc
   def dup: () -> self
 
   # <!-- rdoc-file=proc.c -->
-  # Invokes the block, setting the block's parameters to the values in *params*
-  # using something close to method calling semantics. Returns the value of the
-  # last expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the arguments using
+  # something close to method calling semantics. Returns the value of the last
+  # expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]
@@ -409,9 +409,9 @@ class Proc
   alias === call
 
   # <!-- rdoc-file=proc.c -->
-  # Invokes the block, setting the block's parameters to the values in *params*
-  # using something close to method calling semantics. Returns the value of the
-  # last expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the arguments using
+  # something close to method calling semantics. Returns the value of the last
+  # expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]
@@ -592,14 +592,13 @@ class Proc
 
   # <!--
   #   rdoc-file=proc.c
-  #   - prc.call(params,...)   -> obj
-  #   - prc[params,...]        -> obj
-  #   - prc.(params,...)       -> obj
-  #   - prc.yield(params,...)  -> obj
+  #   - call(...) -> obj
+  #   - self[...] -> obj
+  #   - yield(...) -> obj
   # -->
-  # Invokes the block, setting the block's parameters to the values in *params*
-  # using something close to method calling semantics. Returns the value of the
-  # last expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the arguments using
+  # something close to method calling semantics. Returns the value of the last
+  # expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]
@@ -626,9 +625,9 @@ class Proc
   def call: (?) -> untyped
 
   # <!-- rdoc-file=proc.c -->
-  # Invokes the block, setting the block's parameters to the values in *params*
-  # using something close to method calling semantics. Returns the value of the
-  # last expression evaluated in the block.
+  # Invokes the block, setting the block's parameters to the arguments using
+  # something close to method calling semantics. Returns the value of the last
+  # expression evaluated in the block.
   #
   #     a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
   #     a_proc.call(9, 1, 2, 3)    #=> [9, 18, 27]