rbs 0.13.1 → 0.14.0

data/stdlib/builtin/encoding.rbs

@@ -1,6 +1,6 @@
 class Encoding < Object
   # Returns the hash of available encoding alias and original encoding name.
-  # 
+  #
   #     Encoding.aliases
   #     #=> {"BINARY"=>"ASCII-8BIT", "ASCII"=>"US-ASCII", "ANSI_X3.4-1986"=>"US-ASCII",
   #           "SJIS"=>"Shift_JIS", "eucJP"=>"EUC-JP", "CP932"=>"Windows-31J"}
@@ -9,35 +9,35 @@ class Encoding < Object
   def self.compatible?: (untyped obj1, untyped obj2) -> Encoding?
 
   # Returns default external encoding.
-  # 
+  #
   # The default external encoding is used by default for strings created
   # from the following locations:
-  # 
+  #
   #   - CSV
-  # 
+  #
   #   - [File](https://ruby-doc.org/core-2.6.3/File.html) data read from
   #     disk
-  # 
+  #
   #   - SDBM
-  # 
+  #
   #   - StringIO
-  # 
+  #
   #   - Zlib::GzipReader
-  # 
+  #
   #   - Zlib::GzipWriter
-  # 
+  #
   #   - [String\#inspect](https://ruby-doc.org/core-2.6.3/String.html#method-i-inspect)
-  # 
+  #
   #   - [Regexp\#inspect](https://ruby-doc.org/core-2.6.3/Regexp.html#method-i-inspect)
-  # 
+  #
   # While strings created from these locations will have this encoding, the
   # encoding may not be valid. Be sure to check
   # [String\#valid\_encoding?](https://ruby-doc.org/core-2.6.3/String.html#method-i-valid_encoding-3F)
   # .
-  # 
+  #
   # [File](https://ruby-doc.org/core-2.6.3/File.html) data written to disk
   # will be transcoded to the default external encoding when written.
-  # 
+  #
   # The default external encoding is initialized by the locale or -E option.
   def self.default_external: () -> Encoding
 
@@ -47,43 +47,43 @@ class Encoding < Object
   # Returns default internal encoding. Strings will be transcoded to the
   # default internal encoding in the following places if the default
   # internal encoding is not nil:
-  # 
+  #
   #   - CSV
-  # 
+  #
   #   - Etc.sysconfdir and Etc.systmpdir
-  # 
+  #
   #   - [File](https://ruby-doc.org/core-2.6.3/File.html) data read from
   #     disk
-  # 
+  #
   #   - [File](https://ruby-doc.org/core-2.6.3/File.html) names from
   #     [Dir](https://ruby-doc.org/core-2.6.3/Dir.html)
-  # 
+  #
   #   - [Integer\#chr](https://ruby-doc.org/core-2.6.3/Integer.html#method-i-chr)
-  # 
+  #
   #   - [String\#inspect](https://ruby-doc.org/core-2.6.3/String.html#method-i-inspect)
   #     and
   #     [Regexp\#inspect](https://ruby-doc.org/core-2.6.3/Regexp.html#method-i-inspect)
-  # 
+  #
   #   - Strings returned from Readline
-  # 
+  #
   #   - Strings returned from SDBM
-  # 
+  #
   #   - [Time\#zone](https://ruby-doc.org/core-2.6.3/Time.html#method-i-zone)
-  # 
+  #
   #   - Values from [ENV](https://ruby-doc.org/core-2.6.3/ENV.html)
-  # 
+  #
   #   - Values in ARGV including $PROGRAM\_NAME
-  # 
+  #
   # Additionally
   # [String\#encode](https://ruby-doc.org/core-2.6.3/String.html#method-i-encode)
   # and
   # [String\#encode\!](https://ruby-doc.org/core-2.6.3/String.html#method-i-encode-21)
   # use the default internal encoding if no encoding is given.
-  # 
+  #
   # The locale encoding (\_\_ENCODING\_\_), not
   # [::default\_internal](Encoding.downloaded.ruby_doc#method-c-default_internal)
   # , is used as the encoding of created strings.
-  # 
+  #
   # [::default\_internal](Encoding.downloaded.ruby_doc#method-c-default_internal)
   # is initialized by the source file's internal\_encoding or -E option.
   def self.default_internal: () -> Encoding?
@@ -97,7 +97,7 @@ class Encoding < Object
   def self.list: () -> ::Array[Encoding]
 
   # Returns the list of available encoding names.
-  # 
+  #
   #     Encoding.name_list
   #     #=> ["US-ASCII", "ASCII-8BIT", "UTF-8",
   #           "ISO-8859-1", "Shift_JIS", "EUC-JP",
@@ -106,7 +106,7 @@ class Encoding < Object
   def self.name_list: () -> ::Array[String]
 
   # Returns whether ASCII-compatible or not.
-  # 
+  #
   # ```ruby
   # Encoding::UTF_8.ascii_compatible?     #=> true
   # Encoding::UTF_16BE.ascii_compatible?  #=> false
@@ -116,7 +116,7 @@ class Encoding < Object
   # Returns true for dummy encodings. A dummy encoding is an encoding for
   # which character handling is not properly implemented. It is used for
   # stateful encodings.
-  # 
+  #
   # ```ruby
   # Encoding::ISO_2022_JP.dummy?       #=> true
   # Encoding::UTF_8.dummy?             #=> false
@@ -126,14 +126,14 @@ class Encoding < Object
   def inspect: () -> String
 
   # Returns the name of the encoding.
-  # 
+  #
   # ```ruby
   # Encoding::UTF_8.name      #=> "UTF-8"
   # ```
   def name: () -> String
 
   # Returns the list of name and aliases of the encoding.
-  # 
+  #
   # ```ruby
   # Encoding::WINDOWS_31J.names  #=> ["Windows-31J", "CP932", "csWindows31J"]
   # ```
@@ -142,7 +142,7 @@ class Encoding < Object
   def replicate: (String name) -> Encoding
 
   # Returns the name of the encoding.
-  # 
+  #
   # ```ruby
   # Encoding::UTF_8.name      #=> "UTF-8"
   # ```

data/stdlib/builtin/enumerable.rbs

@@ -11,10 +11,10 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # block is not given, Ruby adds an implicit block of `{ |obj| obj }` which
   # will cause [all?](Enumerable.downloaded.ruby_doc#method-i-all-3F) to
   # return `true` when none of the collection members are `false` or `nil` .
-  # 
+  #
   # If instead a pattern is supplied, the method returns whether `pattern
   # === element` for every collection member.
-  # 
+  #
   #     %w[ant bear cat].all? { |word| word.length >= 3 } #=> true
   #     %w[ant bear cat].all? { |word| word.length >= 4 } #=> false
   #     %w[ant bear cat].all?(/t/)                        #=> false
@@ -30,10 +30,10 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # |obj| obj }` that will cause
   # [any?](Enumerable.downloaded.ruby_doc#method-i-any-3F) to return `true`
   # if at least one of the collection members is not `false` or `nil` .
-  # 
+  #
   # If instead a pattern is supplied, the method returns whether `pattern
   # === element` for any collection member.
-  # 
+  #
   # ```ruby
   # %w[ant bear cat].any? { |word| word.length >= 3 } #=> true
   # %w[ant bear cat].any? { |word| word.length >= 4 } #=> true
@@ -54,7 +54,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # argument is given, the number of items in `enum` that are equal to
   # `item` are counted. If a block is given, it counts the number of
   # elements yielding a true value.
-  # 
+  #
   # ```ruby
   # ary = [1, 2, 4, 2]
   # ary.count               #=> 4
@@ -86,11 +86,11 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
                       | [U] (U arg0) -> ::Enumerator[[ Elem, U ], Return]
 
   # Returns an array containing the items in *enum* .
-  # 
+  #
   # ```ruby
   # (1..7).to_a                       #=> [1, 2, 3, 4, 5, 6, 7]
   # { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a   #=> [["a", 1], ["b", 2], ["c", 3]]
-  # 
+  #
   # require 'prime'
   # Prime.entries 10                  #=> [2, 3, 5, 7]
   # ```
@@ -109,7 +109,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # Returns the first element, or the first `n` elements, of the enumerable.
   # If the enumerable is empty, the first form returns `nil`, and the
   # second form returns an empty array.
-  # 
+  #
   # ```ruby
   # %w[foo bar baz].first     #=> "foo"
   # %w[foo bar baz].first(2)  #=> ["foo", "bar"]
@@ -139,16 +139,16 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # Returns the object in *enum* with the maximum value. The first form
   # assumes all objects implement `Comparable` ; the second uses the block
   # to return *a \<=\> b* .
-  # 
+  #
   # ```ruby
   # a = %w(albatross dog horse)
   # a.max                                   #=> "horse"
   # a.max { |a, b| a.length <=> b.length }  #=> "albatross"
   # ```
-  # 
+  #
   # If the `n` argument is given, maximum `n` elements are returned as an
   # array, sorted in descending order.
-  # 
+  #
   # ```ruby
   # a = %w[albatross dog horse]
   # a.max(2)                                  #=> ["horse", "dog"]
@@ -168,16 +168,16 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # Returns the object in *enum* with the minimum value. The first form
   # assumes all objects implement `Comparable` ; the second uses the block
   # to return *a \<=\> b* .
-  # 
+  #
   # ```ruby
   # a = %w(albatross dog horse)
   # a.min                                   #=> "albatross"
   # a.min { |a, b| a.length <=> b.length }  #=> "dog"
   # ```
-  # 
+  #
   # If the `n` argument is given, minimum `n` elements are returned as a
   # sorted array.
-  # 
+  #
   # ```ruby
   # a = %w[albatross dog horse]
   # a.min(2)                                  #=> ["albatross", "dog"]
@@ -197,7 +197,7 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # Returns a two element array which contains the minimum and the maximum
   # value in the enumerable. The first form assumes all objects implement
   # `Comparable` ; the second uses the block to return *a \<=\> b* .
-  # 
+  #
   # ```ruby
   # a = %w(albatross dog horse)
   # a.minmax                                  #=> ["albatross", "horse"]
@@ -213,10 +213,10 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # returns `true` if the block never returns `true` for all elements. If
   # the block is not given, `none?` will return `true` only if none of the
   # collection members is true.
-  # 
+  #
   # If instead a pattern is supplied, the method returns whether `pattern
   # === element` for none of the collection members.
-  # 
+  #
   # ```ruby
   # %w{ant bear cat}.none? { |word| word.length == 5 } #=> true
   # %w{ant bear cat}.none? { |word| word.length >= 4 } #=> false
@@ -234,10 +234,10 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # returns `true` if the block returns `true` exactly once. If the block is
   # not given, `one?` will return `true` only if exactly one of the
   # collection members is true.
-  # 
+  #
   # If instead a pattern is supplied, the method returns whether `pattern
   # === element` for exactly one collection member.
-  # 
+  #
   # ```ruby
   # %w{ant bear cat}.one? { |word| word.length == 4 }  #=> true
   # %w{ant bear cat}.one? { |word| word.length > 4 }   #=> false
@@ -261,22 +261,22 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
                   | () -> ::Enumerator[Elem, Return]
 
   # Returns an array containing the items in *enum* sorted.
-  # 
+  #
   # Comparisons for the sort will be done using the items’ own `<=>`
   # operator or using an optional code block.
-  # 
+  #
   # The block must implement a comparison between `a` and `b` and return an
   # integer less than 0 when `b` follows `a`, `0` when `a` and `b` are
   # equivalent, or an integer greater than 0 when `a` follows `b` .
-  # 
+  #
   # The result is not guaranteed to be stable. When the comparison of two
   # elements returns `0`, the order of the elements is unpredictable.
-  # 
+  #
   # ```ruby
   # %w(rhea kea flea).sort           #=> ["flea", "kea", "rhea"]
   # (1..10).sort { |a, b| b <=> a }  #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
   # ```
-  # 
+  #
   # See also [\#sort\_by](Enumerable.downloaded.ruby_doc#method-i-sort_by).
   # It implements a Schwartzian transform which is useful when key
   # computation or comparison is expensive.
@@ -294,13 +294,13 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # Implemented in C++
   # Returns the result of interpreting *enum* as a list of `[key, value]`
   # pairs.
-  # 
+  #
   #     %i[hello world].each_with_index.to_h
   #       # => {:hello => 0, :world => 1}
-  # 
+  #
   # If a block is given, the results of the block on each element of the
   # enum will be used as pairs.
-  # 
+  #
   # ```ruby
   # (1..5).to_h {|x| [x, x ** 2]}
   #   #=> {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}
@@ -324,11 +324,11 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   alias reduce inject
 
   # Returns an array containing the items in *enum* .
-  # 
+  #
   # ```ruby
   # (1..7).to_a                       #=> [1, 2, 3, 4, 5, 6, 7]
   # { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a   #=> [["a", 1], ["b", 2], ["c", 3]]
-  # 
+  #
   # require 'prime'
   # Prime.entries 10                  #=> [2, 3, 5, 7]
   # ```
@@ -342,10 +342,10 @@ module Enumerable[unchecked out Elem, out Return]: _Each[Elem, Return]
   # [\#drop\_while](Enumerable.downloaded.ruby_doc#method-i-drop_while)
   # enumerate values only on an as-needed basis. However, if a block is
   # given to zip, values are enumerated immediately.
-  # 
-  # 
+  #
+  #
   # The following program finds pythagorean triples:
-  # 
+  #
   # ```ruby
   # def pythagorean_triples
   #   (1..Float::INFINITY).lazy.flat_map {|z|

data/stdlib/builtin/enumerator.rbs

@@ -1,59 +1,59 @@
 # A class which allows both internal and external iteration.
-# 
+#
 # An [Enumerator](Enumerator) can be created by the
 # following methods.
-# 
+#
 #   - Kernel\#to\_enum
-# 
+#
 #   - Kernel\#enum\_for
-# 
+#
 #   - [::new](Enumerator#method-c-new)
-# 
+#
 # Most methods have two forms: a block form where the contents are
 # evaluated for each item in the enumeration, and a non-block form which
 # returns a new [Enumerator](Enumerator) wrapping the
 # iteration.
-# 
+#
 # ```ruby
 # enumerator = %w(one two three).each
 # puts enumerator.class # => Enumerator
-# 
+#
 # enumerator.each_with_object("foo") do |item, obj|
 #   puts "#{obj}: #{item}"
 # end
-# 
+#
 # # foo: one
 # # foo: two
 # # foo: three
-# 
+#
 # enum_with_obj = enumerator.each_with_object("foo")
 # puts enum_with_obj.class # => Enumerator
-# 
+#
 # enum_with_obj.each do |item, obj|
 #   puts "#{obj}: #{item}"
 # end
-# 
+#
 # # foo: one
 # # foo: two
 # # foo: three
 # ```
-# 
+#
 # This allows you to chain Enumerators together. For example, you can map
 # a list's elements to strings containing the index and the element as a
 # string via:
-# 
+#
 # ```ruby
 # puts %w[foo bar baz].map.with_index { |w, i| "#{i}:#{w}" }
 # # => ["0:foo", "1:bar", "2:baz"]
 # ```
-# 
+#
 # An [Enumerator](Enumerator) can also be used as an
 # external iterator. For example,
 # [\#next](Enumerator#method-i-next) returns the next
 # value of the iterator or raises
 # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) if
 # the [Enumerator](Enumerator) is at the end.
-# 
+#
 # ```ruby
 # e = [1,2,3].each   # returns an enumerator object.
 # puts e.next   # => 1
@@ -61,9 +61,9 @@
 # puts e.next   # => 3
 # puts e.next   # raises StopIteration
 # ```
-# 
+#
 # You can use this to implement an internal iterator as follows:
-# 
+#
 # ```ruby
 # def ext_each(e)
 #   while true
@@ -76,20 +76,20 @@
 #     e.feed y
 #   end
 # end
-# 
+#
 # o = Object.new
-# 
+#
 # def o.each
 #   puts yield
 #   puts yield(1)
 #   puts yield(1, 2)
 #   3
 # end
-# 
+#
 # # use o.each as an internal iterator directly.
 # puts o.each {|*x| puts x; [:b, *x] }
 # # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
-# 
+#
 # # convert o.each to an external iterator for
 # # implementing an internal iterator.
 # puts ext_each(o.to_enum) {|*x| puts x; [:b, *x] }
@@ -112,8 +112,8 @@ class Enumerator[unchecked out Elem, out Return] < Object
   # position forward. When the position reached at the end,
   # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
   # raised.
-  # 
-  # 
+  #
+  #
   # ```ruby
   # a = [1,2,3]
   # e = a.to_enum
@@ -122,7 +122,7 @@ class Enumerator[unchecked out Elem, out Return] < Object
   # p e.next   #=> 3
   # p e.next   #raises StopIteration
   # ```
-  # 
+  #
   # Note that enumeration sequence by `next` does not affect other
   # non-external enumeration methods, unless the underlying iteration
   # methods itself has side-effect, e.g.
@@ -134,10 +134,10 @@ class Enumerator[unchecked out Elem, out Return] < Object
   # internal position forward. When the position reached at the end,
   # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
   # raised.
-  # 
+  #
   # This method can be used to distinguish `yield` and `yield nil` .
-  # 
-  # 
+  #
+  #
   # ```ruby
   # o = Object.new
   # def o.each
@@ -159,7 +159,7 @@ class Enumerator[unchecked out Elem, out Return] < Object
   # p e.next
   # p e.next
   # p e.next
-  # 
+  #
   # ## yield args       next_values      next
   # #  yield            []               nil
   # #  yield 1          [1]              1
@@ -167,7 +167,7 @@ class Enumerator[unchecked out Elem, out Return] < Object
   # #  yield nil        [nil]            nil
   # #  yield [1, 2]     [[1, 2]]         [1, 2]
   # ```
-  # 
+  #
   # Note that `next_values` does not affect other non-external enumeration
   # methods unless underlying iteration method itself has side-effect, e.g.
   # [IO\#each\_line](https://ruby-doc.org/core-2.6.3/IO.html#method-i-each_line)
@@ -178,8 +178,8 @@ class Enumerator[unchecked out Elem, out Return] < Object
   # position forward. If the position is already at the end,
   # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
   # raised.
-  # 
-  # 
+  #
+  #
   # ```ruby
   # a = [1,2,3]
   # e = a.to_enum
@@ -199,8 +199,8 @@ class Enumerator[unchecked out Elem, out Return] < Object
   # already at the end,
   # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html) is
   # raised.
-  # 
-  # 
+  #
+  #
   # ```ruby
   # o = Object.new
   # def o.each
@@ -221,13 +221,13 @@ class Enumerator[unchecked out Elem, out Return] < Object
   def peek_values: () -> ::Array[Elem]
 
   # Rewinds the enumeration sequence to the beginning.
-  # 
+  #
   # If the enclosed object responds to a “rewind” method, it is called.
   def rewind: () -> self
 
   # Returns the size of the enumerator, or `nil` if it can’t be calculated
   # lazily.
-  # 
+  #
   # ```ruby
   # (1..100).to_a.permutation(4).size # => 94109400
   # loop.size # => Float::INFINITY