rbs 0.13.1 → 0.18.0

data/{stdlib/builtin → core}/gc.rbs

@@ -42,7 +42,7 @@ module GC
   # are not guaranteed to be future-compatible, and may be ignored if the
   # underlying implementation does not support them.
   #
-  def self.start: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
+  def self.start: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
 
   # Returns a Hash containing information about the GC.
   #
@@ -132,7 +132,7 @@ module GC
                          | [K] (?Hash[K, untyped] hash) -> ::Hash[::Symbol | K, untyped]
                          | (Symbol key) -> untyped
 
-  def garbage_collect: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
+  def garbage_collect: (?immediate_sweep: boolish immediate_sweep, ?immediate_mark: boolish immediate_mark, ?full_mark: boolish full_mark) -> nil
 end
 
 # internal constants
@@ -221,7 +221,7 @@ module GC::Profiler
   # `:HEAP_LIVE_OBJECTS`
   # `:HEAP_FREE_OBJECTS`
   # `:HAVE_FINALIZE`
-  # :   
+  # :
   #
   def self.raw_data: () -> ::Array[::Hash[Symbol, untyped]]
 

data/{stdlib/builtin → core}/hash.rbs

@@ -106,7 +106,7 @@
 # See also Object#hash and Object#eql?
 #
 class Hash[unchecked out K, unchecked out V] < Object
-  include Enumerable[[K, V], Hash[K, V]]
+  include Enumerable[[K, V]]
 
   # Creates a new hash populated with the given objects.
   #
@@ -143,7 +143,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 < h1    #=> false
   #     h1 < h1    #=> false
   #
-  def <: (::Hash[K, V]) -> bool
+  def <: [A, B] (::Hash[A, B]) -> bool
 
   # Returns `true` if *hash* is subset of *other* or equals to *other*.
   #
@@ -153,7 +153,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 <= h1   #=> false
   #     h1 <= h1   #=> true
   #
-  def <=: (::Hash[K, V]) -> bool
+  def <=: [A, B] (::Hash[A, B]) -> bool
 
   # Equality---Two hashes are equal if they each contain the same number of keys
   # and if each key-value pair is equal to (according to Object#==) the
@@ -183,7 +183,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 > h1    #=> true
   #     h1 > h1    #=> false
   #
-  def >: (::Hash[K, V]) -> bool
+  def >: [A, B] (::Hash[A, B]) -> bool
 
   # Returns `true` if *other* is subset of *hash* or equals to *hash*.
   #
@@ -193,7 +193,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h2 >= h1   #=> true
   #     h1 >= h1   #=> true
   #
-  def >=: (::Hash[K, V]) -> bool
+  def >=: [A, B] (::Hash[A, B]) -> bool
 
   # Element Reference---Retrieves the *value* object corresponding to the *key*
   # object. If not found, returns the default value (see Hash::new for details).
@@ -230,7 +230,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   def any?: () -> bool
           | (untyped pattern) -> bool
-          | () { (K, V) -> bool } -> bool
+          | () { (K, V) -> boolish } -> bool
 
   # Searches through the hash comparing *obj* with the key using `==`. Returns the
   # key-value pair (two elements array) or `nil` if no match is found.  See
@@ -360,7 +360,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h = { "a" => 100, "b" => 200, "c" => 300 }
   #     h.delete_if {|key, value| key >= "b" }   #=> {"a"=>100}
   #
-  def delete_if: () { (K arg0, V arg1) -> bool } -> self
+  def delete_if: () { (K, V) -> boolish } -> self
                | () -> ::Enumerator[[ K, V ], self]
 
   # Extracts the nested value specified by the sequence of *key* objects by
@@ -498,14 +498,14 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Hash#filter is an alias for Hash#select.
   #
-  def filter: () { (K arg0, V arg1) -> bool } -> self
+  def filter: () { (K, V) -> boolish } -> self
             | () -> ::Enumerator[[ K, V ], self]
 
   # Equivalent to Hash#keep_if, but returns `nil` if no changes were made.
   #
   # Hash#filter! is an alias for Hash#select!.
   #
-  def filter!: () { (K arg0, V arg1) -> bool } -> self?
+  def filter!: () { (K, V) -> boolish } -> self?
              | () -> ::Enumerator[[ K, V ], self?]
 
   # Returns a new array that is a one-dimensional flattening of this hash. That
@@ -604,7 +604,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # See also Hash#select!.
   #
-  def keep_if: () { (K, V) -> bool } -> self
+  def keep_if: () { (K, V) -> boolish } -> self
              | () -> ::Enumerator[[ K, V ], self]
 
   # Returns the key of an occurrence of a given value. If the value is not found,
@@ -720,8 +720,8 @@ class Hash[unchecked out K, unchecked out V] < Object
   #
   # Hash#update is an alias for Hash#merge!.
   #
-  def merge!: [A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V]
-            | [A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> (C) } -> ::Hash[A | K, B | V | C]
+  def merge!: (*::Hash[K, V] other_hashes) -> self
+            | (*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> (V) } -> self
 
   # Searches through the hash comparing *obj* with the value using `==`. Returns
   # the first key-value pair (two-element array) that matches. See also
@@ -758,19 +758,19 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h.reject {|k,v| v > 100}  #=> {"a" => 100}
   #
   def reject: () -> ::Enumerator[[ K, V ], self]
-            | () { (K arg0, V arg1) -> bool } -> self
+            | () { (K, V) -> boolish } -> self
 
   # Equivalent to Hash#delete_if, but returns `nil` if no changes were made.
   #
   def reject!: () -> ::Enumerator[[ K, V ], self?]
-            | () { (K arg0, V arg1) -> bool } -> self?
+            | () { (K, V) -> boolish } -> self?
 
   # Replaces the contents of *hsh* with the contents of *other_hash*.
   #
   #     h = { "a" => 100, "b" => 200 }
   #     h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}
   #
-  def replace: [A, B] (Hash[A, B] | _ToHash[A, B]) -> Hash[A, B]
+  def replace: (Hash[K, V]) -> self
 
   # Returns a new hash consisting of entries for which the block returns true.
   #

data/{stdlib/builtin → core}/io.rbs

@@ -2,7 +2,7 @@
 # output in Ruby. An I/O stream may be *duplexed* (that is,
 # bidirectional), and so may use more than one native operating system
 # stream.
-# 
+#
 # Many of the examples in this section use the
 # [File](https://ruby-doc.org/core-2.6.3/File.html) class, the only
 # standard subclass of [IO](IO). The two classes are
@@ -10,47 +10,47 @@
 # [File](https://ruby-doc.org/core-2.6.3/File.html) class, the Socket
 # library subclasses from [IO](IO) (such as TCPSocket
 # or UDPSocket).
-# 
+#
 # The
 # [Kernel\#open](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-open)
 # method can create an [IO](IO) (or
 # [File](https://ruby-doc.org/core-2.6.3/File.html) ) object for these
 # types of arguments:
-# 
+#
 #   - A plain string represents a filename suitable for the underlying
 #     operating system.
-# 
+#
 #   - A string starting with `"|"` indicates a subprocess. The remainder
 #     of the string following the `"|"` is invoked as a process with
 #     appropriate input/output channels connected to it.
-# 
+#
 #   - A string equal to `"|-"` will create another Ruby instance as a
 #     subprocess.
-# 
+#
 # The [IO](IO) may be opened with different file modes
 # (read-only, write-only) and encodings for proper conversion. See
 # [::new](IO#method-c-new) for these options. See
 # [Kernel\#open](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-open)
 # for details of the various command formats described above.
-# 
+#
 # [::popen](IO#method-c-popen), the Open3 library, or
 # Process\#spawn may also be used to communicate with subprocesses through
 # an [IO](IO).
-# 
+#
 # Ruby will convert pathnames between different operating system
 # conventions if possible. For instance, on a Windows system the filename
 # `"/gumby/ruby/test.rb"` will be opened as `"\gumby\ruby\test.rb"` . When
 # specifying a Windows-style filename in a Ruby string, remember to escape
 # the backslashes:
-# 
+#
 # ```ruby
 # "C:\\gumby\\ruby\\test.rb"
 # ```
-# 
+#
 # Our examples here will use the Unix-style forward slashes;
 # File::ALT\_SEPARATOR can be used to get the platform-specific separator
 # character.
-# 
+#
 # The global constant [ARGF](https://ruby-doc.org/core-2.6.3/ARGF.html)
 # (also accessible as `$<` ) provides an IO-like stream which allows
 # access to all files mentioned on the command line (or STDIN if no files
@@ -59,44 +59,44 @@
 # and its alias
 # [ARGF\#filename](https://ruby-doc.org/core-2.6.3/ARGF.html#method-i-filename)
 # are provided to access the name of the file currently being read.
-# 
-# 
+#
+#
 # The io/console extension provides methods for interacting with the
 # console. The console can be accessed from IO.console or the standard
 # input/output/error [IO](IO) objects.
-# 
+#
 # Requiring io/console adds the following methods:
-# 
+#
 #   - IO::console
-# 
+#
 #   - IO\#raw
-# 
+#
 #   - IO\#raw\!
-# 
+#
 #   - IO\#cooked
-# 
+#
 #   - IO\#cooked\!
-# 
+#
 #   - IO\#getch
-# 
+#
 #   - IO\#echo=
-# 
+#
 #   - IO\#echo?
-# 
+#
 #   - IO\#noecho
-# 
+#
 #   - IO\#winsize
-# 
+#
 #   - IO\#winsize=
-# 
+#
 #   - IO\#iflush
-# 
+#
 #   - IO\#ioflush
-# 
+#
 #   - IO\#oflush
-# 
+#
 # Example:
-# 
+#
 # ```ruby
 # require 'io/console'
 # rows, columns = $stdout.winsize
@@ -105,13 +105,13 @@
 class IO < Object
   include File::Constants
 
-  include Enumerable[String, IO]
+  include Enumerable[String]
 
   def <<: (untyped arg0) -> self
 
   def advise: (Symbol arg0, ?Integer offset, ?Integer len) -> NilClass
 
-  def autoclose=: (bool arg0) -> bool
+  def autoclose=: (boolish) -> bool
 
   # Returns `true` if the underlying file descriptor of *ios* will be closed
   # automatically at its finalization, otherwise `false` .
@@ -119,11 +119,11 @@ class IO < Object
 
   # Puts *ios* into binary mode. Once a stream is in binary mode, it cannot
   # be reset to nonbinary mode.
-  # 
+  #
   #   - newline conversion disabled
-  # 
+  #
   #   - encoding conversion disabled
-  # 
+  #
   #   - content is treated as ASCII-8BIT
   def binmode: () -> self
 
@@ -134,17 +134,17 @@ class IO < Object
   # stream is unavailable for any further data operations; an `IOError` is
   # raised if such an attempt is made. I/O streams are automatically closed
   # when they are claimed by the garbage collector.
-  # 
+  #
   # If *ios* is opened by `IO.popen`, `close` sets `$?` .
-  # 
+  #
   # Calling this method on closed [IO](IO.downloaded.ruby_doc) object is
   # just ignored since Ruby 2.3.
   def close: () -> NilClass
 
-  def close_on_exec=: (bool arg0) -> bool
+  def close_on_exec=: (boolish) -> bool
 
   # Returns `true` if *ios* will be closed on exec.
-  # 
+  #
   # ```ruby
   # f = open("/dev/null")
   # f.close_on_exec?                 #=> false
@@ -158,18 +158,18 @@ class IO < Object
   # Closes the read end of a duplex I/O stream (i.e., one that contains both
   # a read and a write stream, such as a pipe). Will raise an `IOError` if
   # the stream is not duplexed.
-  # 
+  #
   # ```ruby
   # f = IO.popen("/bin/sh","r+")
   # f.close_read
   # f.readlines
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     prog.rb:3:in `readlines': not opened for reading (IOError)
   #      from prog.rb:3
-  # 
+  #
   # Calling this method on closed [IO](IO.downloaded.ruby_doc) object is
   # just ignored since Ruby 2.3.
   def close_read: () -> NilClass
@@ -177,26 +177,26 @@ class IO < Object
   # Closes the write end of a duplex I/O stream (i.e., one that contains
   # both a read and a write stream, such as a pipe). Will raise an `IOError`
   # if the stream is not duplexed.
-  # 
+  #
   # ```ruby
   # f = IO.popen("/bin/sh","r+")
   # f.close_write
   # f.print "nowhere"
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     prog.rb:3:in `write': not opened for writing (IOError)
   #      from prog.rb:3:in `print'
   #      from prog.rb:3
-  # 
+  #
   # Calling this method on closed [IO](IO.downloaded.ruby_doc) object is
   # just ignored since Ruby 2.3.
   def close_write: () -> NilClass
 
   # Returns `true` if *ios* is completely closed (for duplex streams, both
   # reader and writer), `false` otherwise.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.close         #=> nil
@@ -224,29 +224,29 @@ class IO < Object
   # Returns true if *ios* is at end of file that means there are no more
   # data to read. The stream must be opened for reading or an `IOError` will
   # be raised.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # dummy = f.readlines
   # f.eof   #=> true
   # ```
-  # 
+  #
   # If *ios* is a stream such as pipe or socket, `IO#eof?` blocks until the
   # other end sends some data or closes it.
-  # 
+  #
   # ```ruby
   # r, w = IO.pipe
   # Thread.new { sleep 1; w.close }
   # r.eof?  #=> true after 1 second blocking
-  # 
+  #
   # r, w = IO.pipe
   # Thread.new { sleep 1; w.puts "a" }
   # r.eof?  #=> false after 1 second blocking
-  # 
+  #
   # r, w = IO.pipe
   # r.eof?  # blocks forever
   # ```
-  # 
+  #
   # Note that `IO#eof?` reads data to the input byte buffer. So `IO#sysread`
   # may not behave as you intend with `IO#eof?`, unless you call
   # `IO#rewind` first (which is not available for some streams).
@@ -255,35 +255,35 @@ class IO < Object
   def fcntl: (Integer integer_cmd, String | Integer arg) -> Integer
 
   # Immediately writes all buffered data in *ios* to disk.
-  # 
+  #
   # If the underlying operating system does not support *fdatasync(2)* ,
   # `IO#fsync` is called instead (which might raise a `NotImplementedError`
   # ).
   def fdatasync: () -> Integer?
 
   # Returns an integer representing the numeric file descriptor for *ios* .
-  # 
+  #
   # ```ruby
   # $stdin.fileno    #=> 0
   # $stdout.fileno   #=> 1
   # ```
-  # 
-  # 
-  # 
+  #
+  #
+  #
   # Also aliased as: [to\_i](IO.downloaded.ruby_doc#method-i-to_i)
   def fileno: () -> Integer
 
   # Flushes any buffered data within *ios* to the underlying operating
   # system (note that this is Ruby internal buffering only; the OS may
   # buffer the data as well).
-  # 
+  #
   # ```ruby
   # $stdout.print "no newline"
   # $stdout.flush
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   # ```ruby
   # no newline
   # ```
@@ -293,14 +293,14 @@ class IO < Object
   # differs from using `IO#sync=` . The latter ensures that data is flushed
   # from Ruby’s buffers, but does not guarantee that the underlying
   # operating system actually writes it to disk.
-  # 
+  #
   # `NotImplementedError` is raised if the underlying operating system does
   # not support *fsync(2)* .
   def fsync: () -> Integer?
 
   # Gets the next 8-bit byte (0..255) from *ios* . Returns `nil` if called
   # at end of file.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.getbyte   #=> 84
@@ -310,7 +310,7 @@ class IO < Object
 
   # Reads a one-character string from *ios* . Returns `nil` if called at end
   # of file.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.getc   #=> "h"
@@ -334,7 +334,7 @@ class IO < Object
 
   # Returns `true` if *ios* is associated with a terminal device (tty),
   # `false` otherwise.
-  # 
+  #
   # ```ruby
   # File.new("testfile").isatty   #=> false
   # File.new("/dev/tty").isatty   #=> true
@@ -347,14 +347,14 @@ class IO < Object
   # number of newlines encountered. The two values will differ if
   # [gets](IO.downloaded.ruby_doc#method-i-gets) is called with a separator
   # other than newline.
-  # 
+  #
   # Methods that use `$/` like [each](IO.downloaded.ruby_doc#method-i-each)
   # , [lines](IO.downloaded.ruby_doc#method-i-lines) and
   # [readline](IO.downloaded.ruby_doc#method-i-readline) will also increment
   # `lineno` .
-  # 
+  #
   # See also the `$.` variable.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.lineno   #=> 0
@@ -369,7 +369,7 @@ class IO < Object
 
   # Returns the process ID of a child process associated with *ios* . This
   # will be set by `IO.popen` .
-  # 
+  #
   # ```ruby
   # pipe = IO.popen("-")
   # if pipe
@@ -378,15 +378,15 @@ class IO < Object
   #   $stderr.puts "In child, pid is #{$$}"
   # end
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     In child, pid is 26209
   #     In parent, child pid is 26209
   def pid: () -> Integer
 
   # Returns the current offset (in bytes) of *ios* .
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.pos    #=> 0
@@ -416,7 +416,7 @@ class IO < Object
 
   # Reads a one-character string from *ios* . Raises an `EOFError` on end of
   # file.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.readchar   #=> "h"
@@ -435,7 +435,7 @@ class IO < Object
             | (String other_IO_or_path, ?String mode_str) -> IO
 
   # Positions *ios* to the beginning of input, resetting `lineno` to zero.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.readline   #=> "This is line one\n"
@@ -443,7 +443,7 @@ class IO < Object
   # f.lineno     #=> 0
   # f.readline   #=> "This is line one\n"
   # ```
-  # 
+  #
   # Note that it cannot be used with streams such as pipes, ttys, and
   # sockets.
   def rewind: () -> Integer
@@ -454,7 +454,7 @@ class IO < Object
                   | (?String | Encoding ext_or_ext_int_enc, ?String | Encoding int_enc) -> self
 
   # Returns status information for *ios* as an object of type `File::Stat` .
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # s = f.stat
@@ -467,14 +467,14 @@ class IO < Object
   # Returns the current “sync mode” of *ios* . When sync mode is true, all
   # output is immediately flushed to the underlying operating system and is
   # not buffered by Ruby internally. See also `IO#fsync` .
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.sync   #=> false
   # ```
   def sync: () -> bool
 
-  def sync=: (bool arg0) -> bool
+  def sync=: (boolish) -> bool
 
   def sysread: (Integer maxlen, String outbuf) -> String
 
@@ -483,7 +483,7 @@ class IO < Object
   def syswrite: (_ToS arg0) -> Integer
 
   # Returns the current offset (in bytes) of *ios* .
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # f.pos    #=> 0
@@ -497,7 +497,7 @@ class IO < Object
 
   # Returns `true` if *ios* is associated with a terminal device (tty),
   # `false` otherwise.
-  # 
+  #
   # ```ruby
   # File.new("testfile").isatty   #=> false
   # File.new("/dev/tty").isatty   #=> true
@@ -514,7 +514,7 @@ class IO < Object
 
   def self.binwrite: (String name, _ToS arg0, ?Integer offset, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode) -> Integer
 
-  def self.copy_stream: (String | IO src, String | IO dst, ?Integer copy_length, ?Integer src_offset) -> Integer
+  def self.copy_stream: (_Reader src, _Writer dst, ?Integer copy_length, ?Integer src_offset) -> Integer
 
   def self.popen: (*untyped args) -> untyped
 
@@ -522,7 +522,7 @@ class IO < Object
 
   def self.readlines: (String name, ?String sep, ?Integer limit, ?external_encoding: String external_encoding, ?internal_encoding: String internal_encoding, ?encoding: String encoding, ?textmode: untyped textmode, ?binmode: untyped binmode, ?autoclose: untyped autoclose, ?mode: String mode) -> ::Array[String]
 
-  def self.select: (::Array[IO]? read_array, ?::Array[IO]? write_array, ?::Array[IO]? error_array, ?Integer? timeout) -> ::Array[::Array[IO]]?
+  def self.select: (::Array[io]? read_array, ?::Array[io]? write_array, ?::Array[io]? error_array, ?Integer? timeout) -> ::Array[::Array[io]]?
 
   def self.sysopen: (String path, ?String mode, ?String perm) -> Integer
 
@@ -547,29 +547,29 @@ class IO < Object
   # Returns true if *ios* is at end of file that means there are no more
   # data to read. The stream must be opened for reading or an `IOError` will
   # be raised.
-  # 
+  #
   # ```ruby
   # f = File.new("testfile")
   # dummy = f.readlines
   # f.eof   #=> true
   # ```
-  # 
+  #
   # If *ios* is a stream such as pipe or socket, `IO#eof?` blocks until the
   # other end sends some data or closes it.
-  # 
+  #
   # ```ruby
   # r, w = IO.pipe
   # Thread.new { sleep 1; w.close }
   # r.eof?  #=> true after 1 second blocking
-  # 
+  #
   # r, w = IO.pipe
   # Thread.new { sleep 1; w.puts "a" }
   # r.eof?  #=> false after 1 second blocking
-  # 
+  #
   # r, w = IO.pipe
   # r.eof?  # blocks forever
   # ```
-  # 
+  #
   # Note that `IO#eof?` reads data to the input byte buffer. So `IO#sysread`
   # may not behave as you intend with `IO#eof?`, unless you call
   # `IO#rewind` first (which is not available for some streams).