rbs 3.0.0.dev.2 → 3.0.0.dev.3

data/core/array.rbs

@@ -1,80 +1,127 @@
 # <!-- rdoc-file=array.c -->
 # An Array is an ordered, integer-indexed collection of objects, called
-# *elements*.  Any object may be an Array element.
+# *elements*. Any object (even another array) may be an array element, and an
+# array can contain objects of different types.
 #
 # ## Array Indexes
 #
 # Array indexing starts at 0, as in C or Java.
 #
 # A positive index is an offset from the first element:
+#
 # *   Index 0 indicates the first element.
 # *   Index 1 indicates the second element.
 # *   ...
 #
 #
 # A negative index is an offset, backwards, from the end of the array:
+#
 # *   Index -1 indicates the last element.
 # *   Index -2 indicates the next-to-last element.
 # *   ...
 #
 #
-# A non-negative index is *in range* if it is smaller than the size of the
-# array.  For a 3-element array:
+# A non-negative index is *in range* if and only if it is smaller than the size
+# of the array.  For a 3-element array:
+#
 # *   Indexes 0 through 2 are in range.
 # *   Index 3 is out of range.
 #
 #
-# A negative index is *in range* if its absolute value is not larger than the
-# size of the array.  For a 3-element array:
+# A negative index is *in range* if and only if its absolute value is not larger
+# than the size of the array.  For a 3-element array:
+#
 # *   Indexes -1 through -3 are in range.
 # *   Index -4 is out of range.
 #
 #
+# Although the effective index into an array is always an integer, some methods
+# (both within and outside of class Array) accept one or more non-integer
+# arguments that are [integer-convertible
+# objects](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
+#
 # ## Creating Arrays
 #
 # You can create an Array object explicitly with:
 #
-# *   An [array literal](doc/syntax/literals_rdoc.html#label-Array+Literals).
+# *   An [array literal](rdoc-ref:literals.rdoc@Array+Literals):
+#
+#         [1, 'one', :one, [2, 'two', :two]]
 #
+# *   A [%w or %W: string-array
+#     Literal](rdoc-ref:literals.rdoc@25w+and+-25W-3A+String-Array+Literals):
 #
-# You can convert certain objects to Arrays with:
+#         %w[foo bar baz] # => ["foo", "bar", "baz"]
+#         %w[1 % *]       # => ["1", "%", "*"]
 #
-# *   Method [Array](Kernel.html#method-i-Array).
+# *   A [%i pr %I: symbol-array
+#     Literal](rdoc-ref:literals.rdoc@25i+and+-25I-3A+Symbol-Array+Literals):
 #
+#         %i[foo bar baz] # => [:foo, :bar, :baz]
+#         %i[1 % *]       # => [:"1", :%, :*]
 #
-# An Array can contain different types of objects.  For example, the array below
-# contains an Integer, a String and a Float:
+# *   Method Kernel#Array:
 #
-#     ary = [1, "two", 3.0] #=> [1, "two", 3.0]
+#         Array(["a", "b"])             # => ["a", "b"]
+#         Array(1..5)                   # => [1, 2, 3, 4, 5]
+#         Array(key: :value)            # => [[:key, :value]]
+#         Array(nil)                    # => []
+#         Array(1)                      # => [1]
+#         Array({:a => "a", :b => "b"}) # => [[:a, "a"], [:b, "b"]]
 #
-# An array can also be created by calling Array.new with zero, one (the initial
-# size of the Array) or two arguments (the initial size and a default object).
+# *   Method Array.new:
 #
-#     ary = Array.new    #=> []
-#     Array.new(3)       #=> [nil, nil, nil]
-#     Array.new(3, true) #=> [true, true, true]
+#         Array.new               # => []
+#         Array.new(3)            # => [nil, nil, nil]
+#         Array.new(4) {Hash.new} # => [{}, {}, {}, {}]
+#         Array.new(3, true)      # => [true, true, true]
 #
-# Note that the second argument populates the array with references to the same
-# object.  Therefore, it is only recommended in cases when you need to
-# instantiate arrays with natively immutable objects such as Symbols, numbers,
-# true or false.
+#     Note that the last example above populates the array with references to
+#     the same object. This is recommended only in cases where that object is a
+#     natively immutable object such as a symbol, a numeric, `nil`, `true`, or
+#     `false`.
 #
-# To create an array with separate objects a block can be passed instead. This
-# method is safe to use with mutable objects such as hashes, strings or other
-# arrays:
+#     Another way to create an array with various objects, using a block; this
+#     usage is safe for mutable objects such as hashes, strings or other arrays:
 #
-#     Array.new(4) {Hash.new}    #=> [{}, {}, {}, {}]
-#     Array.new(4) {|i| i.to_s } #=> ["0", "1", "2", "3"]
+#         Array.new(4) {|i| i.to_s } # => ["0", "1", "2", "3"]
 #
-# This is also a quick way to build up multi-dimensional arrays:
+#     Here is a way to create a multi-dimensional array:
 #
-#     empty_table = Array.new(3) {Array.new(3)}
-#     #=> [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]
+#         Array.new(3) {Array.new(3)}
+#         # => [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]
 #
-# An array can also be created by using the Array() method, provided by Kernel,
-# which tries to call #to_ary, then #to_a on its argument.
 #
-#     Array({:a => "a", :b => "b"}) #=> [[:a, "a"], [:b, "b"]]
+# A number of Ruby methods, both in the core and in the standard library,
+# provide instance method `to_a`, which converts an object to an array.
+#
+# *   ARGF#to_a
+# *   Array#to_a
+# *   Enumerable#to_a
+# *   Hash#to_a
+# *   MatchData#to_a
+# *   NilClass#to_a
+# *   OptionParser#to_a
+# *   Range#to_a
+# *   Set#to_a
+# *   Struct#to_a
+# *   Time#to_a
+# *   Benchmark::Tms#to_a
+# *   CSV::Table#to_a
+# *   Enumerator::Lazy#to_a
+# *   Gem::List#to_a
+# *   Gem::NameTuple#to_a
+# *   Gem::Platform#to_a
+# *   Gem::RequestSet::Lockfile::Tokenizer#to_a
+# *   Gem::SourceList#to_a
+# *   OpenSSL::X509::Extension#to_a
+# *   OpenSSL::X509::Name#to_a
+# *   Racc::ISet#to_a
+# *   Rinda::RingFinger#to_a
+# *   Ripper::Lexer::Elem#to_a
+# *   RubyVM::InstructionSequence#to_a
+# *   YAML::DBM#to_a
+#
 #
 # ## Example Usage
 #
@@ -269,298 +316,210 @@
 #
 # First, what's elsewhere. Class Array:
 #
-# *   Inherits from [class
-#     Object](Object.html#class-Object-label-What-27s+Here).
-# *   Includes [module
-#     Enumerable](Enumerable.html#module-Enumerable-label-What-27s+Here), which
+# *   Inherits from [class Object](rdoc-ref:Object@What-27s+Here).
+# *   Includes [module Enumerable](rdoc-ref:Enumerable@What-27s+Here), which
 #     provides dozens of additional methods.
 #
 #
 # Here, class Array provides methods that are useful for:
 #
-# *   [Creating an Array](#class-Array-label-Methods+for+Creating+an+Array)
-# *   [Querying](#class-Array-label-Methods+for+Querying)
-# *   [Comparing](#class-Array-label-Methods+for+Comparing)
-# *   [Fetching](#class-Array-label-Methods+for+Fetching)
-# *   [Assigning](#class-Array-label-Methods+for+Assigning)
-# *   [Deleting](#class-Array-label-Methods+for+Deleting)
-# *   [Combining](#class-Array-label-Methods+for+Combining)
-# *   [Iterating](#class-Array-label-Methods+for+Iterating)
-# *   [Converting](#class-Array-label-Methods+for+Converting)
-# *   [And more....](#class-Array-label-Other+Methods)
+# *   [Creating an Array](rdoc-ref:Array@Methods+for+Creating+an+Array)
+# *   [Querying](rdoc-ref:Array@Methods+for+Querying)
+# *   [Comparing](rdoc-ref:Array@Methods+for+Comparing)
+# *   [Fetching](rdoc-ref:Array@Methods+for+Fetching)
+# *   [Assigning](rdoc-ref:Array@Methods+for+Assigning)
+# *   [Deleting](rdoc-ref:Array@Methods+for+Deleting)
+# *   [Combining](rdoc-ref:Array@Methods+for+Combining)
+# *   [Iterating](rdoc-ref:Array@Methods+for+Iterating)
+# *   [Converting](rdoc-ref:Array@Methods+for+Converting)
+# *   [And more....](rdoc-ref:Array@Other+Methods)
 #
 #
 # ### Methods for Creating an Array
 #
-# ::[]
-# :   Returns a new array populated with given objects.
-# ::new
-# :   Returns a new array.
-# ::try_convert
-# :   Returns a new array created from a given object.
+# *   ::[]: Returns a new array populated with given objects.
+# *   ::new: Returns a new array.
+# *   ::try_convert: Returns a new array created from a given object.
 #
 #
 # ### Methods for Querying
 #
-# #length, #size
-# :   Returns the count of elements.
-# #include?
-# :   Returns whether any element `==` a given object.
-# #empty?
-# :   Returns whether there are no elements.
-# #all?
-# :   Returns whether all elements meet a given criterion.
-# #any?
-# :   Returns whether any element meets a given criterion.
-# #none?
-# :   Returns whether no element `==` a given object.
-# #one?
-# :   Returns whether exactly one element `==` a given object.
-# #count
-# :   Returns the count of elements that meet a given criterion.
-# #find_index, #index
-# :   Returns the index of the first element that meets a given criterion.
-# #rindex
-# :   Returns the index of the last element that meets a given criterion.
-# #hash
-# :   Returns the integer hash code.
+# *   #length, #size: Returns the count of elements.
+# *   #include?: Returns whether any element `==` a given object.
+# *   #empty?: Returns whether there are no elements.
+# *   #all?: Returns whether all elements meet a given criterion.
+# *   #any?: Returns whether any element meets a given criterion.
+# *   #none?: Returns whether no element `==` a given object.
+# *   #one?: Returns whether exactly one element `==` a given object.
+# *   #count: Returns the count of elements that meet a given criterion.
+# *   #find_index, #index: Returns the index of the first element that meets a
+#     given criterion.
+# *   #rindex: Returns the index of the last element that meets a given
+#     criterion.
+# *   #hash: Returns the integer hash code.
 #
 #
 # ### Methods for Comparing
-# [#<=>](#method-i-3C-3D-3E)
-# :   Returns -1, 0, or 1 as `self` is less than, equal to, or greater than a
-#     given object.
-# [#==](#method-i-3D-3D)
-# :   Returns whether each element in `self` is `==` to the corresponding
-#     element in a given object.
-# #eql?
-# :   Returns whether each element in `self` is `eql?` to the corresponding
+#
+# *   #<=>: Returns -1, 0, or 1 * as `self` is less than, equal to, or greater
+#     than a given object.
+# *   #==: Returns whether each element in `self` is `==` to the corresponding
 #     element in a given object.
+# *   #eql?: Returns whether each element in `self` is `eql?` to the
+#     corresponding element in a given object.
 #
 #
 # ### Methods for Fetching
 #
 # These methods do not modify `self`.
 #
-# #[]
-# :   Returns one or more elements.
-# #fetch
-# :   Returns the element at a given offset.
-# #first
-# :   Returns one or more leading elements.
-# #last
-# :   Returns one or more trailing elements.
-# #max
-# :   Returns one or more maximum-valued elements, as determined by `<=>` or a
-#     given block.
-# #max
-# :   Returns one or more minimum-valued elements, as determined by `<=>` or a
-#     given block.
-# #minmax
-# :   Returns the minimum-valued and maximum-valued elements, as determined by
-#     `<=>` or a given block.
-# #assoc
-# :   Returns the first element that is an array whose first element `==` a
-#     given object.
-# #rassoc
-# :   Returns the first element that is an array whose second element `==` a
-#     given object.
-# #at
-# :   Returns the element at a given offset.
-# #values_at
-# :   Returns the elements at given offsets.
-# #dig
-# :   Returns the object in nested objects that is specified by a given index
-#     and additional arguments.
-# #drop
-# :   Returns trailing elements as determined by a given index.
-# #take
-# :   Returns leading elements as determined by a given index.
-# #drop_while
-# :   Returns trailing elements as determined by a given block.
-# #take_while
-# :   Returns leading elements as determined by a given block.
-# #slice
-# :   Returns consecutive elements as determined by a given argument.
-# #sort
-# :   Returns all elements in an order determined by `<=>` or a given block.
-# #reverse
-# :   Returns all elements in reverse order.
-# #compact
-# :   Returns an array containing all non-`nil` elements.
-# #select, #filter
-# :   Returns an array containing elements selected by a given block.
-# #uniq
-# :   Returns an array containing non-duplicate elements.
-# #rotate
-# :   Returns all elements with some rotated from one end to the other.
-# #bsearch
-# :   Returns an element selected via a binary search as determined by a given
+# *   #[]: Returns one or more elements.
+# *   #fetch: Returns the element at a given offset.
+# *   #first: Returns one or more leading elements.
+# *   #last: Returns one or more trailing elements.
+# *   #max: Returns one or more maximum-valued elements, as determined by `<=>`
+#     or a given block.
+# *   #min: Returns one or more minimum-valued elements, as determined by `<=>`
+#     or a given block.
+# *   #minmax: Returns the minimum-valued and maximum-valued elements, as
+#     determined by `<=>` or a given block.
+# *   #assoc: Returns the first element that is an array whose first element
+#     `==` a given object.
+# *   #rassoc: Returns the first element that is an array whose second element
+#     `==` a given object.
+# *   #at: Returns the element at a given offset.
+# *   #values_at: Returns the elements at given offsets.
+# *   #dig: Returns the object in nested objects that is specified by a given
+#     index and additional arguments.
+# *   #drop: Returns trailing elements as determined by a given index.
+# *   #take: Returns leading elements as determined by a given index.
+# *   #drop_while: Returns trailing elements as determined by a given block.
+# *   #take_while: Returns leading elements as determined by a given block.
+# *   #slice: Returns consecutive elements as determined by a given argument.
+# *   #sort: Returns all elements in an order determined by `<=>` or a given
+#     block.
+# *   #reverse: Returns all elements in reverse order.
+# *   #compact: Returns an array containing all non-`nil` elements.
+# *   #select, #filter: Returns an array containing elements selected by a given
 #     block.
-# #bsearch_index
-# :   Returns the index of an element selected via a binary search as determined
-#     by a given block.
-# #sample
-# :   Returns one or more random elements.
-# #shuffle
-# :   Returns elements in a random order.
+# *   #uniq: Returns an array containing non-duplicate elements.
+# *   #rotate: Returns all elements with some rotated from one end to the other.
+# *   #bsearch: Returns an element selected via a binary search as determined by
+#     a given block.
+# *   #bsearch_index: Returns the index of an element selected via a binary
+#     search as determined by a given block.
+# *   #sample: Returns one or more random elements.
+# *   #shuffle: Returns elements in a random order.
 #
 #
 # ### Methods for Assigning
 #
 # These methods add, replace, or reorder elements in `self`.
 #
-# #[]=
-# :   Assigns specified elements with a given object.
-# #push, #append, #<<
-# :   Appends trailing elements.
-# #unshift, #prepend
-# :   Prepends leading elements.
-# #insert
-# :   Inserts given objects at a given offset; does not replace elements.
-# #concat
-# :   Appends all elements from given arrays.
-# #fill
-# :   Replaces specified elements with specified objects.
-# #replace
-# :   Replaces the content of `self` with the content of a given array.
-# #reverse!
-# :   Replaces `self` with its elements reversed.
-# #rotate!
-# :   Replaces `self` with its elements rotated.
-# #shuffle!
-# :   Replaces `self` with its elements in random order.
-# #sort!
-# :   Replaces `self` with its elements sorted, as determined by `<=>` or a
+# *   #[]=: Assigns specified elements with a given object.
+# *   #push, #append, #<<: Appends trailing elements.
+# *   #unshift, #prepend: Prepends leading elements.
+# *   #insert: Inserts given objects at a given offset; does not replace
+#     elements.
+# *   #concat: Appends all elements from given arrays.
+# *   #fill: Replaces specified elements with specified objects.
+# *   #replace: Replaces the content of `self` with the content of a given
+#     array.
+# *   #reverse!: Replaces `self` with its elements reversed.
+# *   #rotate!: Replaces `self` with its elements rotated.
+# *   #shuffle!: Replaces `self` with its elements in random order.
+# *   #sort!: Replaces `self` with its elements sorted, as determined by `<=>`
+#     or a given block.
+# *   #sort_by!: Replaces `self` with its elements sorted, as determined by a
 #     given block.
-# #sort_by!
-# :   Replaces `self` with its elements sorted, as determined by a given block.
 #
 #
 # ### Methods for Deleting
 #
 # Each of these methods removes elements from `self`:
 #
-# #pop
-# :   Removes and returns the last element.
-# #shift
-# :   Removes and returns the first element.
-# #compact!
-# :   Removes all non-`nil` elements.
-# #delete
-# :   Removes elements equal to a given object.
-# #delete_at
-# :   Removes the element at a given offset.
-# #delete_if
-# :   Removes elements specified by a given block.
-# #keep_if
-# :   Removes elements not specified by a given block.
-# #reject!
-# :   Removes elements specified by a given block.
-# #select!, #filter!
-# :   Removes elements not specified by a given block.
-# #slice!
-# :   Removes and returns a sequence of elements.
-# #uniq!
-# :   Removes duplicates.
+# *   #pop: Removes and returns the last element.
+# *   #shift:  Removes and returns the first element.
+# *   #compact!: Removes all `nil` elements.
+# *   #delete: Removes elements equal to a given object.
+# *   #delete_at: Removes the element at a given offset.
+# *   #delete_if: Removes elements specified by a given block.
+# *   #keep_if: Removes elements not specified by a given block.
+# *   #reject!: Removes elements specified by a given block.
+# *   #select!, #filter!: Removes elements not specified by a given block.
+# *   #slice!: Removes and returns a sequence of elements.
+# *   #uniq!: Removes duplicates.
 #
 #
 # ### Methods for Combining
 #
-# [#&](#method-i-26)
-# :   Returns an array containing elements found both in `self` and a given
+# *   #&: Returns an array containing elements found both in `self` and a given
 #     array.
-# #intersection
-# :   Returns an array containing elements found both in `self` and in each
-#     given array.
-# #+
-# :   Returns an array containing all elements of `self` followed by all
+# *   #intersection: Returns an array containing elements found both in `self`
+#     and in each given array.
+# *   #+: Returns an array containing all elements of `self` followed by all
 #     elements of a given array.
-# #-
-# :   Returns an array containiing all elements of `self` that are not found in
-#     a given array.
-# [#|](#method-i-7C)
-# :   Returns an array containing all elements of `self` and all elements of a
-#     given array, duplicates removed.
-# #union
-# :   Returns an array containing all elements of `self` and all elements of
-#     given arrays, duplicates removed.
-# #difference
-# :   Returns an array containing all elements of `self` that are not found in
-#     any of the given arrays..
-# #product
-# :   Returns or yields all combinations of elements from `self` and given
-#     arrays.
+# *   #-: Returns an array containing all elements of `self` that are not found
+#     in a given array.
+# *   #|: Returns an array containing all elements of `self` and all elements of
+#     a given array, duplicates removed.
+# *   #union: Returns an array containing all elements of `self` and all
+#     elements of given arrays, duplicates removed.
+# *   #difference: Returns an array containing all elements of `self` that are
+#     not found in any of the given arrays..
+# *   #product: Returns or yields all combinations of elements from `self` and
+#     given arrays.
 #
 #
 # ### Methods for Iterating
 #
-# #each
-# :   Passes each element to a given block.
-# #reverse_each
-# :   Passes each element, in reverse order, to a given block.
-# #each_index
-# :   Passes each element index to a given block.
-# #cycle
-# :   Calls a given block with each element, then does so again, for a specified
-#     number of times, or forever.
-# #combination
-# :   Calls a given block with combinations of elements of `self`; a combination
-#     does not use the same element more than once.
-# #permutation
-# :   Calls a given block with permutations of elements of `self`; a permutation
-#     does not use the same element more than once.
-# #repeated_combination
-# :   Calls a given block with combinations of elements of `self`; a combination
-#     may use the same element more than once.
-# #repeated_permutation
-# :   Calls a given block with permutations of elements of `self`; a permutation
-#     may use the same element more than once.
+# *   #each: Passes each element to a given block.
+# *   #reverse_each:  Passes each element, in reverse order, to a given block.
+# *   #each_index: Passes each element index to a given block.
+# *   #cycle: Calls a given block with each element, then does so again, for a
+#     specified number of times, or forever.
+# *   #combination: Calls a given block with combinations of elements of `self`;
+#     a combination does not use the same element more than once.
+# *   #permutation: Calls a given block with permutations of elements of `self`;
+#     a permutation does not use the same element more than once.
+# *   #repeated_combination: Calls a given block with combinations of elements
+#     of `self`; a combination may use the same element more than once.
+# *   #repeated_permutation: Calls a given block with permutations of elements
+#     of `self`; a permutation may use the same element more than once.
 #
 #
 # ### Methods for Converting
 #
-# #map, #collect
-# :   Returns an array containing the block return-value for each element.
-# #map!, #collect!
-# :   Replaces each element with a block return-value.
-# #flatten
-# :   Returns an array that is a recursive flattening of `self`.
-# #flatten!
-# :   Replaces each nested array in `self` with the elements from that array.
-# #inspect, #to_s
-# :   Returns a new String containing the elements.
-# #join
-# :   Returns a newsString containing the elements joined by the field
+# *   #map, #collect: Returns an array containing the block return-value for
+#     each element.
+# *   #map!, #collect!: Replaces each element with a block return-value.
+# *   #flatten: Returns an array that is a recursive flattening of `self`.
+# *   #flatten!: Replaces each nested array in `self` with the elements from
+#     that array.
+# *   #inspect, #to_s: Returns a new String containing the elements.
+# *   #join: Returns a newsString containing the elements joined by the field
 #     separator.
-# #to_a
-# :   Returns `self` or a new array containing all elements.
-# #to_ary
-# :   Returns `self`.
-# #to_h
-# :   Returns a new hash formed from the elements.
-# #transpose
-# :   Transposes `self`, which must be an array of arrays.
-# #zip
-# :   Returns a new array of arrays containing `self` and given arrays; follow
-#     the link for details.
+# *   #to_a: Returns `self` or a new array containing all elements.
+# *   #to_ary: Returns `self`.
+# *   #to_h: Returns a new hash formed from the elements.
+# *   #transpose: Transposes `self`, which must be an array of arrays.
+# *   #zip: Returns a new array of arrays containing `self` and given arrays;
+#     follow the link for details.
 #
 #
 # ### Other Methods
 #
-# #*
-# :   Returns one of the following:
+# *   #*: Returns one of the following:
+#
 #     *   With integer argument `n`, a new array that is the concatenation of
 #         `n` copies of `self`.
 #     *   With string argument `field_separator`, a new string that is
 #         equivalent to `join(field_separator)`.
 #
-# #abbrev
-# :   Returns a hash of unambiguous abbreviations for elements.
-# #pack
-# :   Packs the elements into a binary sequence.
-# #sum
-# :   Returns a sum of elements according to either `+` or a given block.
+#
+# *   #abbrev: Returns a hash of unambiguous abbreviations for elements.
+# *   #pack: Packs the elements into a binary sequence.
+# *   #sum: Returns a sum of elements according to either `+` or a given block.
 #
 %a{annotate:rdoc:source:from=array.c}
 class Array[unchecked out Elem] < Object
@@ -580,23 +539,27 @@ class Array[unchecked out Elem] < Object
   #
   # With no block and a single Array argument `array`, returns a new Array formed
   # from `array`:
+  #
   #     a = Array.new([:foo, 'bar', 2])
   #     a.class # => Array
   #     a # => [:foo, "bar", 2]
   #
   # With no block and a single Integer argument `size`, returns a new Array of the
   # given size whose elements are all `nil`:
+  #
   #     a = Array.new(3)
   #     a # => [nil, nil, nil]
   #
   # With no block and arguments `size` and `default_value`, returns an Array of
   # the given size; each element is that same `default_value`:
+  #
   #     a = Array.new(3, 'x')
   #     a # => ['x', 'x', 'x']
   #
   # With a block and argument `size`, returns an Array of the given size; the
   # block is called with each successive integer `index`; the element for that
   # `index` is the return value from the block:
+  #
   #     a = Array.new(3) {|index| "Element #{index}" }
   #     a # => ["Element 0", "Element 1", "Element 2"]
   #
@@ -645,10 +608,12 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns a new Array containing each element found in both `array` and Array
   # `other_array`; duplicates are omitted; items are compared using `eql?`:
+  #
   #     [0, 1, 2, 3] & [1, 2] # => [1, 2]
   #     [0, 1, 0, 1] & [0, 1] # => [0, 1]
   #
   # Preserves order from `array`:
+  #
   #     [0, 1, 2] & [3, 2, 1, 0] # => [0, 1, 2]
   #
   # Related: Array#intersection.
@@ -662,11 +627,13 @@ class Array[unchecked out Elem] < Object
   # -->
   # When non-negative argument Integer `n` is given, returns a new Array built by
   # concatenating the `n` copies of `self`:
+  #
   #     a = ['x', 'y']
   #     a * 3 # => ["x", "y", "x", "y", "x", "y"]
   #
   # When String argument `string_separator` is given, equivalent to
   # `array.join(string_separator)`:
+  #
   #     [0, [0, 1], {foo: 0}] * ', ' # => "0, 0, 1, {:foo=>0}"
   #
   def *: (string str) -> ::String
@@ -678,6 +645,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns a new Array containing all elements of `array` followed by all
   # elements of `other_array`:
+  #
   #     a = [0, 1] + [2, 3]
   #     a # => [0, 1, 2, 3]
   #
@@ -692,6 +660,7 @@ class Array[unchecked out Elem] < Object
   # Returns a new Array containing only those elements from `array` that are not
   # found in Array `other_array`; items are compared using `eql?`; the order from
   # `array` is preserved:
+  #
   #     [0, 1, 1, 2, 1, 1, 3, 1, 1] - [1] # => [0, 2, 3]
   #     [0, 1, 2, 3] - [3, 0] # => [1, 2]
   #     [0, 1, 2] - [4] # => [0, 1, 2]
@@ -705,10 +674,12 @@ class Array[unchecked out Elem] < Object
   #   - array << object -> self
   # -->
   # Appends `object` to `self`; returns `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a << :baz # => [:foo, "bar", 2, :baz]
   #
   # Appends `object` as one element, even if it is another Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a << [3, 4]
   #     a1 # => [:foo, "bar", 2, [3, 4]]
@@ -724,19 +695,25 @@ class Array[unchecked out Elem] < Object
   # other_array[i]`.
   #
   # Returns -1 if any result is -1:
+  #
   #     [0, 1, 2] <=> [0, 1, 3] # => -1
   #
   # Returns 1 if any result is 1:
+  #
   #     [0, 1, 2] <=> [0, 1, 1] # => 1
   #
   # When all results are zero:
+  #
   # *   Returns -1 if `array` is smaller than `other_array`:
+  #
   #         [0, 1, 2] <=> [0, 1, 2, 3] # => -1
   #
   # *   Returns 1 if `array` is larger than `other_array`:
+  #
   #         [0, 1, 2] <=> [0, 1] # => 1
   #
   # *   Returns 0 if `array` and `other_array` are the same size:
+  #
   #         [0, 1, 2] <=> [0, 1, 2] # => 0
   #
   def <=>: (untyped) -> ::Integer?
@@ -747,6 +724,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns `true` if both `array.size == other_array.size` and for each index `i`
   # in `array`, `array[i] == other_array[i]`:
+  #
   #     a0 = [:foo, 'bar', 2]
   #     a1 = [:foo, 'bar', 2.0]
   #     a1 == a0 # => true
@@ -774,12 +752,14 @@ class Array[unchecked out Elem] < Object
   #
   # When a single Integer argument `index` is given, returns the element at offset
   # `index`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0] # => :foo
   #     a[2] # => 2
   #     a # => [:foo, "bar", 2]
   #
   # If `index` is negative, counts relative to the end of `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[-1] # => 2
   #     a[-2] # => "bar"
@@ -788,12 +768,14 @@ class Array[unchecked out Elem] < Object
   #
   # When two Integer arguments `start` and `length` are given, returns a new Array
   # of size `length` containing successive elements beginning at offset `start`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0, 2] # => [:foo, "bar"]
   #     a[1, 2] # => ["bar", 2]
   #
   # If `start + length` is greater than `self.length`, returns all elements from
   # offset `start` to the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0, 4] # => [:foo, "bar", 2]
   #     a[1, 3] # => ["bar", 2]
@@ -805,6 +787,7 @@ class Array[unchecked out Elem] < Object
   #
   # When a single Range argument `range` is given, treats `range.min` as `start`
   # above and `range.size` as `length` above:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0..1] # => [:foo, "bar"]
   #     a[1..2] # => ["bar", 2]
@@ -812,18 +795,21 @@ class Array[unchecked out Elem] < Object
   # Special case: If `range.start == a.size`, returns a new empty Array.
   #
   # If `range.end` is negative, calculates the end index from the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0..-1] # => [:foo, "bar", 2]
   #     a[0..-2] # => [:foo, "bar"]
   #     a[0..-3] # => [:foo]
   #
   # If `range.start` is negative, calculates the start index from the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[-1..2] # => [2]
   #     a[-2..2] # => ["bar", 2]
   #     a[-3..2] # => [:foo, "bar", 2]
   #
   # If `range.start` is larger than the array size, returns `nil`.
+  #
   #     a = [:foo, 'bar', 2]
   #     a[4..1] # => nil
   #     a[4..0] # => nil
@@ -831,11 +817,13 @@ class Array[unchecked out Elem] < Object
   #
   # When a single Enumerator::ArithmeticSequence argument `aseq` is given, returns
   # an Array of elements corresponding to the indexes produced by the sequence.
+  #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..).step(2)] # => ["data1", "data2", "data3"]
   #
   # Unlike slicing with range, if the start or the end of the arithmetic sequence
   # is larger than array size, throws RangeError.
+  #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..11).step(2)]
   #     # RangeError (((1..11).step(2)) out of range)
@@ -844,6 +832,7 @@ class Array[unchecked out Elem] < Object
   #
   # If given a single argument, and its type is not one of the listed, tries to
   # convert it to Integer, and raises if it is impossible:
+  #
   #     a = [:foo, 'bar', 2]
   #     # Raises TypeError (no implicit conversion of Symbol into Integer):
   #     a[:foo]
@@ -866,16 +855,19 @@ class Array[unchecked out Elem] < Object
   # `self`.
   #
   # If `index` is non-negative, assigns `object` the element at offset `index`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0] = 'foo' # => "foo"
   #     a # => ["foo", "bar", 2]
   #
   # If `index` is greater than `self.length`, extends the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[7] = 'foo' # => "foo"
   #     a # => [:foo, "bar", 2, nil, nil, nil, nil, "foo"]
   #
   # If `index` is negative, counts backwards from the end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[-1] = 'two' # => "two"
   #     a # => [:foo, "bar", "two"]
@@ -883,11 +875,13 @@ class Array[unchecked out Elem] < Object
   # When Integer arguments `start` and `length` are given and `object` is not an
   # Array, removes `length - 1` elements beginning at offset `start`, and assigns
   # `object` at offset `start`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0, 2] = 'foo' # => "foo"
   #     a # => ["foo", 2]
   #
   # If `start` is negative, counts backwards from the end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[-2, 2] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
@@ -895,17 +889,20 @@ class Array[unchecked out Elem] < Object
   # If `start` is non-negative and outside the array (` >= self.size`), extends
   # the array with `nil`, assigns `object` at offset `start`, and ignores
   # `length`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[6, 50] = 'foo' # => "foo"
   #     a # => [:foo, "bar", 2, nil, nil, nil, "foo"]
   #
   # If `length` is zero, shifts elements at and following offset `start` and
   # assigns `object` at offset `start`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[1, 0] = 'foo' # => "foo"
   #     a # => [:foo, "foo", "bar", 2]
   #
   # If `length` is too large for the existing array, does not extend the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[1, 5] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
@@ -913,29 +910,34 @@ class Array[unchecked out Elem] < Object
   # When Range argument `range` is given and `object` is an Array, removes `length
   # - 1` elements beginning at offset `start`, and assigns `object` at offset
   # `start`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0..1] = 'foo' # => "foo"
   #     a # => ["foo", 2]
   #
   # if `range.begin` is negative, counts backwards from the end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[-2..2] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
   #
   # If the array length is less than `range.begin`, assigns `object` at offset
   # `range.begin`, and ignores `length`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[6..50] = 'foo' # => "foo"
   #     a # => [:foo, "bar", 2, nil, nil, nil, "foo"]
   #
   # If `range.end` is zero, shifts elements at and following offset `start` and
   # assigns `object` at offset `start`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[1..0] = 'foo' # => "foo"
   #     a # => [:foo, "foo", "bar", 2]
   #
   # If `range.end` is negative, assigns `object` at offset `start`, retains
   # `range.end.abs -1` elements past that, and removes those beyond:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[1..-1] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
@@ -949,6 +951,7 @@ class Array[unchecked out Elem] < Object
   #
   # If `range.end` is too large for the existing array, replaces array elements,
   # but does not extend the array with `nil` values:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[1..5] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
@@ -971,6 +974,7 @@ class Array[unchecked out Elem] < Object
   #
   # With no block given and no argument, returns `true` if `self` contains only
   # truthy elements, `false` otherwise:
+  #
   #     [0, 1, :foo].all? # => true
   #     [0, nil, 2].all? # => false
   #     [].all? # => true
@@ -978,11 +982,13 @@ class Array[unchecked out Elem] < Object
   # With a block given and no argument, calls the block with each element in
   # `self`; returns `true` if the block returns only truthy values, `false`
   # otherwise:
+  #
   #     [0, 1, 2].all? { |element| element < 3 } # => true
   #     [0, 1, 2].all? { |element| element < 2 } # => false
   #
   # If argument `obj` is given, returns `true` if `obj.===` every element, `false`
   # otherwise:
+  #
   #     ['food', 'fool', 'foot'].all?(/foo/) # => true
   #     ['food', 'drink'].all?(/bar/) # => false
   #     [].all?(/foo/) # => true
@@ -1005,6 +1011,7 @@ class Array[unchecked out Elem] < Object
   #
   # With no block given and no argument, returns `true` if `self` has any truthy
   # element, `false` otherwise:
+  #
   #     [nil, 0, false].any? # => true
   #     [nil, false].any? # => false
   #     [].any? # => false
@@ -1012,11 +1019,13 @@ class Array[unchecked out Elem] < Object
   # With a block given and no argument, calls the block with each element in
   # `self`; returns `true` if the block returns any truthy value, `false`
   # otherwise:
+  #
   #     [0, 1, 2].any? {|element| element > 1 } # => true
   #     [0, 1, 2].any? {|element| element > 2 } # => false
   #
   # If argument `obj` is given, returns `true` if `obj`.`===` any element, `false`
   # otherwise:
+  #
   #     ['food', 'drink'].any?(/foo/) # => true
   #     ['food', 'drink'].any?(/bar/) # => false
   #     [].any?(/foo/) # => false
@@ -1031,10 +1040,12 @@ class Array[unchecked out Elem] < Object
   # Appends trailing elements.
   #
   # Appends each argument in `objects` to `self`;  returns `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.push(:baz, :bat) # => [:foo, "bar", 2, :baz, :bat]
   #
   # Appends each argument as one element, even if it is another Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.push([:baz, :bat], [:bam, :bad])
   #     a1 # => [:foo, "bar", 2, [:baz, :bat], [:bam, :bad]]
@@ -1051,6 +1062,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns the first element in `self` that is an Array whose first element `==`
   # `obj`:
+  #
   #     a = [{foo: 0}, [2, 4], [4, 5, 6], [4, 5]]
   #     a.assoc(4) # => [4, 5, 6]
   #
@@ -1100,6 +1112,7 @@ class Array[unchecked out Elem] < Object
   #   - array.clear -> self
   # -->
   # Removes all elements from `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.clear # => []
   #
@@ -1112,6 +1125,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Calls the block, if given, with each element of `self`; returns a new Array
   # whose elements are the return values from the block:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.map {|element| element.class }
   #     a1 # => [Symbol, String, Integer]
@@ -1133,10 +1147,12 @@ class Array[unchecked out Elem] < Object
   # -->
   # Calls the block, if given, with each element; replaces the element with the
   # block's return value:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.map! { |element| element.class } # => [Symbol, String, Integer]
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.map!
   #     a1 # => #<Enumerator: [:foo, "bar", 2]:map!>
@@ -1159,35 +1175,43 @@ class Array[unchecked out Elem] < Object
   # `self`.
   #
   # Example:
+  #
   #     a = [0, 1, 2]
   #     a.combination(2) {|combination| p combination }
   #
   # Output:
+  #
   #     [0, 1]
   #     [0, 2]
   #     [1, 2]
   #
   # Another example:
+  #
   #     a = [0, 1, 2]
   #     a.combination(3) {|combination| p combination }
   #
   # Output:
+  #
   #     [0, 1, 2]
   #
   # When `n` is zero, calls the block once with a new empty Array:
+  #
   #     a = [0, 1, 2]
   #     a1 = a.combination(0) {|combination| p combination }
   #
   # Output:
+  #
   #     []
   #
   # When `n` is out of range (negative or larger than `self.size`), does not call
   # the block:
+  #
   #     a = [0, 1, 2]
   #     a.combination(-1) {|combination| fail 'Cannot happen' }
   #     a.combination(4) {|combination| fail 'Cannot happen' }
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [0, 1, 2]
   #     a.combination(2) # => #<Enumerator: [0, 1, 2]:combination(2)>
   #
@@ -1199,6 +1223,7 @@ class Array[unchecked out Elem] < Object
   #   - array.compact -> new_array
   # -->
   # Returns a new Array containing all non-`nil` elements from `self`:
+  #
   #     a = [nil, 0, nil, 1, nil, 2, nil]
   #     a.compact # => [0, 1, 2]
   #
@@ -1220,6 +1245,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Adds to `array` all elements from each Array in `other_arrays`; returns
   # `self`:
+  #
   #     a = [0, 1]
   #     a.concat([2, 3], [4, 5]) # => [0, 1, 2, 3, 4, 5]
   #
@@ -1234,19 +1260,22 @@ class Array[unchecked out Elem] < Object
   # Returns a count of specified elements.
   #
   # With no argument and no block, returns the count of all elements:
+  #
   #     [0, 1, 2].count # => 3
   #     [].count # => 0
   #
   # With argument `obj`, returns the count of elements `==` to `obj`:
+  #
   #     [0, 1, 2, 0.0].count(0) # => 2
   #     [0, 1, 2].count(3) # => 0
   #
   # With no argument and a block given, calls the block with each element; returns
   # the count of elements for which the block returns a truthy value:
+  #
   #     [0, 1, 2, 3].count {|element| element > 1} # => 2
   #
   # With argument `obj` and a block given, issues a warning, ignores the block,
-  # and returns the count of elements `==` to `obj`:
+  # and returns the count of elements `==` to `obj`.
   #
   def count: () -> ::Integer
            | (Elem obj) -> ::Integer
@@ -1262,15 +1291,18 @@ class Array[unchecked out Elem] < Object
   # When called with positive Integer argument `count` and a block, calls the
   # block with each element, then does so again, until it has done so `count`
   # times; returns `nil`:
+  #
   #     output = []
   #     [0, 1].cycle(2) {|element| output.push(element) } # => nil
   #     output # => [0, 1, 0, 1]
   #
   # If `count` is zero or negative, does not call the block:
+  #
   #     [0, 1].cycle(0) {|element| fail 'Cannot happen' } # => nil
   #     [0, 1].cycle(-1) {|element| fail 'Cannot happen' } # => nil
   #
   # When a block is given, and argument is omitted or `nil`, cycles forever:
+  #
   #     # Prints 0 and 1 forever.
   #     [0, 1].cycle {|element| puts element }
   #     [0, 1].cycle(nil) {|element| puts element }
@@ -1296,10 +1328,11 @@ class Array[unchecked out Elem] < Object
   #   - array.delete(obj) -> deleted_object
   #   - array.delete(obj) {|nosuch| ... } -> deleted_object or block_return
   # -->
-  # Removes zero or more elements from `self`; returns `self`.
+  # Removes zero or more elements from `self`.
   #
   # When no block is given, removes from `self` each element `ele` such that `ele
   # == obj`; returns the last deleted element:
+  #
   #     s1 = 'bar'; s2 = 'bar'
   #     a = [:foo, s1, 2, s2]
   #     a.delete('bar') # => "bar"
@@ -1312,12 +1345,14 @@ class Array[unchecked out Elem] < Object
   #
   # If any such elements are found, ignores the block and returns the last deleted
   # element:
+  #
   #     s1 = 'bar'; s2 = 'bar'
   #     a = [:foo, s1, 2, s2]
   #     deleted_obj = a.delete('bar') {|obj| fail 'Cannot happen' }
   #     a # => [:foo, 2]
   #
   # If no such elements are found, returns the block's return value:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.delete(:nosuch) {|obj| "#{obj} not found" } # => "nosuch not found"
   #
@@ -1331,6 +1366,7 @@ class Array[unchecked out Elem] < Object
   # Deletes an element from `self`, per the given Integer `index`.
   #
   # When `index` is non-negative, deletes the element at offset `index`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.delete_at(1) # => "bar"
   #     a # => [:foo, 2]
@@ -1338,6 +1374,7 @@ class Array[unchecked out Elem] < Object
   # If index is too large, returns `nil`.
   #
   # When `index` is negative, counts backward from the end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.delete_at(-2) # => "bar"
   #     a # => [:foo, 2]
@@ -1351,14 +1388,18 @@ class Array[unchecked out Elem] < Object
   #   - array.delete_if {|element| ... } -> self
   #   - array.delete_if -> Enumerator
   # -->
-  # Removes each element in `self` for which the block returns a truthy value;
-  # returns `self`:
-  #     a = [:foo, 'bar', 2, 'bat']
-  #     a.delete_if {|element| element.to_s.start_with?('b') } # => [:foo, 2]
+  # Removes each element in +self+ for which the block returns a truthy value;
+  #     returns +self+:
   #
-  # Returns a new Enumerator if no block given:
-  #     a = [:foo, 'bar', 2]
-  #     a.delete_if # => #<Enumerator: [:foo, "bar", 2]:delete_if>
+  #       a = [:foo, 'bar', 2, 'bat']
+  #       a.delete_if {|element| element.to_s.start_with?('b') } # => [:foo, 2]
+  #
+  #     Returns a new \Enumerator if no block given:
+  #
+  #       a = [:foo, 'bar', 2]
+  #       a.delete_if # => #<Enumerator: [:foo, "bar", 2]:delete_if>
+  #
+  # 3
   #
   def delete_if: () { (Elem item) -> boolish } -> self
                | () -> ::Enumerator[Elem, self]
@@ -1370,6 +1411,7 @@ class Array[unchecked out Elem] < Object
   # Returns a new Array containing only those elements from `self` that are not
   # found in any of the Arrays `other_arrays`; items are compared using `eql?`;
   # order from `self` is preserved:
+  #
   #     [0, 1, 1, 2, 1, 1, 3, 1, 1].difference([1]) # => [0, 2, 3]
   #     [0, 1, 2, 3].difference([3, 0], [1, 3]) # => [2]
   #     [0, 1, 2].difference([4]) # => [0, 1, 2]
@@ -1389,6 +1431,7 @@ class Array[unchecked out Elem] < Object
   # [Dig Methods](rdoc-ref:dig_methods.rdoc).
   #
   # Examples:
+  #
   #     a = [:foo, [:bar, :baz, [:bat, :bam]]]
   #     a.dig(1) # => [:bar, :baz, [:bat, :bam]]
   #     a.dig(1, 2) # => [:bat, :bam]
@@ -1406,6 +1449,7 @@ class Array[unchecked out Elem] < Object
   # `n` is a non-negative Integer; does not modify `self`.
   #
   # Examples:
+  #
   #     a = [0, 1, 2, 3, 4, 5]
   #     a.drop(0) # => [0, 1, 2, 3, 4, 5]
   #     a.drop(1) # => [1, 2, 3, 4, 5]
@@ -1424,10 +1468,12 @@ class Array[unchecked out Elem] < Object
   # With a block given, calls the block with each successive element of `self`;
   # stops if the block returns `false` or `nil`; returns a new Array *omitting*
   # those elements for which the block returned a truthy value:
+  #
   #     a = [0, 1, 2, 3, 4, 5]
   #     a.drop_while {|element| element < 3 } # => [3, 4, 5]
   #
   # With no block given, returns a new Enumerator:
+  #
   #     [0, 1].drop_while # => # => #<Enumerator: [0, 1]:drop_while>
   #
   def drop_while: () { (Elem obj) -> boolish } -> ::Array[Elem]
@@ -1442,29 +1488,35 @@ class Array[unchecked out Elem] < Object
   #
   # When a block given, passes each successive array element to the block; returns
   # `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.each {|element|  puts "#{element.class} #{element}" }
   #
   # Output:
+  #
   #     Symbol foo
   #     String bar
   #     Integer 2
   #
   # Allows the array to be modified during iteration:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.each {|element| puts element; a.clear if element.to_s.start_with?('b') }
   #
   # Output:
+  #
   #     foo
   #     bar
   #
   # When no block given, returns a new Enumerator:
   #     a = [:foo, 'bar', 2]
+  #
   #     e = a.each
   #     e # => #<Enumerator: [:foo, "bar", 2]:each>
   #     a1 = e.each {|element|  puts "#{element.class} #{element}" }
   #
   # Output:
+  #
   #     Symbol foo
   #     String bar
   #     Integer 2
@@ -1483,29 +1535,35 @@ class Array[unchecked out Elem] < Object
   #
   # When a block given, passes each successive array index to the block; returns
   # `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.each_index {|index|  puts "#{index} #{a[index]}" }
   #
   # Output:
+  #
   #     0 foo
   #     1 bar
   #     2 2
   #
   # Allows the array to be modified during iteration:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.each_index {|index| puts index; a.clear if index > 0 }
   #
   # Output:
+  #
   #     0
   #     1
   #
   # When no block given, returns a new Enumerator:
+  #
   #     a = [:foo, 'bar', 2]
   #     e = a.each_index
   #     e # => #<Enumerator: [:foo, "bar", 2]:each_index>
   #     a1 = e.each {|index|  puts "#{index} #{a[index]}"}
   #
   # Output:
+  #
   #     0 foo
   #     1 bar
   #     2 2
@@ -1529,14 +1587,15 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns `true` if `self` and `other_array` are the same size, and if, for each
   # index `i` in `self`, `self[i].eql? other_array[i]`:
+  #
   #     a0 = [:foo, 'bar', 2]
   #     a1 = [:foo, 'bar', 2]
   #     a1.eql?(a0) # => true
   #
   # Otherwise, returns `false`.
   #
-  # This method is different from method [Array#==](#method-i-3D-3D), which
-  # compares using method `Object#==`.
+  # This method is different from method Array#==, which compares using method
+  # `Object#==`.
   #
   def eql?: (untyped other) -> bool
 
@@ -1550,16 +1609,19 @@ class Array[unchecked out Elem] < Object
   #
   # With the single Integer argument `index`, returns the element at offset
   # `index`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.fetch(1) # => "bar"
   #
   # If `index` is negative, counts from the end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.fetch(-1) # => 2
   #     a.fetch(-2) # => "bar"
   #
   # With arguments `index` and `default_value`, returns the element at offset
   # `index` if index is in range, otherwise returns `default_value`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.fetch(1, nil) # => "bar"
   #
@@ -1590,6 +1652,7 @@ class Array[unchecked out Elem] < Object
   #
   # With argument `obj` and no block given, replaces all elements with that one
   # object:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a # => ["a", "b", "c", "d"]
   #     a.fill(:X) # => [:X, :X, :X, :X]
@@ -1599,10 +1662,12 @@ class Array[unchecked out Elem] < Object
   #
   # If `start` is in range (`0 <= start < array.size`), replaces all elements from
   # offset `start` through the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, 2) # => ["a", "b", :X, :X]
   #
   # If `start` is too large (`start >= array.size`), does nothing:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, 4) # => ["a", "b", "c", "d"]
   #     a = ['a', 'b', 'c', 'd']
@@ -1610,10 +1675,12 @@ class Array[unchecked out Elem] < Object
   #
   # If `start` is negative, counts from the end (starting index is `start +
   # array.size`):
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, -2) # => ["a", "b", :X, :X]
   #
   # If `start` is too small (less than and far from zero), replaces all elements:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, -6) # => [:X, :X, :X, :X]
   #     a = ['a', 'b', 'c', 'd']
@@ -1624,20 +1691,24 @@ class Array[unchecked out Elem] < Object
   #
   # If `start` is in range, replaces `length` elements beginning at offset
   # `start`:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, 1, 1) # => ["a", :X, "c", "d"]
   #
   # If `start` is negative, counts from the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, -2, 1) # => ["a", "b", :X, "d"]
   #
   # If `start` is large (`start >= array.size`), extends `self` with `nil`:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, 5, 0) # => ["a", "b", "c", "d", nil]
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, 5, 2) # => ["a", "b", "c", "d", nil, :X, :X]
   #
   # If `length` is zero or negative, replaces no elements:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, 1, 0) # => ["a", "b", "c", "d"]
   #     a.fill(:X, 1, -1) # => ["a", "b", "c", "d"]
@@ -1647,14 +1718,17 @@ class Array[unchecked out Elem] < Object
   #
   # If the range is positive and ascending (`0 < range.begin <= range.end`),
   # replaces elements from `range.begin` to `range.end`:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, (1..1)) # => ["a", :X, "c", "d"]
   #
   # If `range.first` is negative, replaces no elements:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, (-1..1)) # => ["a", "b", "c", "d"]
   #
   # If `range.last` is negative, counts from the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, (0..-2)) # => [:X, :X, :X, "d"]
   #     a = ['a', 'b', 'c', 'd']
@@ -1662,6 +1736,7 @@ class Array[unchecked out Elem] < Object
   #
   # If `range.last` and `range.last` are both negative, both count from the end of
   # the array:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(:X, (-1..-1)) # => ["a", "b", "c", :X]
   #     a = ['a', 'b', 'c', 'd']
@@ -1669,29 +1744,34 @@ class Array[unchecked out Elem] < Object
   #
   # With no arguments and a block given, calls the block with each index; replaces
   # the corresponding element with the block's return value:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]
   #
   # With argument `start` and a block given, calls the block with each index from
   # offset `start` to the end; replaces the corresponding element with the block's
-  # return value:
+  # return value.
   #
   # If start is in range (`0 <= start < array.size`), replaces from offset `start`
   # to the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(1) { |index| "new_#{index}" } # => ["a", "new_1", "new_2", "new_3"]
   #
   # If `start` is too large(`start >= array.size`), does nothing:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(4) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(4) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]
   #
   # If `start` is negative, counts from the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(-2) { |index| "new_#{index}" } # => ["a", "b", "new_2", "new_3"]
   #
   # If start is too small (`start <= -array.size`, replaces all elements:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(-6) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]
   #     a = ['a', 'b', 'c', 'd']
@@ -1703,20 +1783,24 @@ class Array[unchecked out Elem] < Object
   #
   # If `start` is in range, replaces `length` elements beginning at offset
   # `start`:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(1, 1) { |index| "new_#{index}" } # => ["a", "new_1", "c", "d"]
   #
   # If start is negative, counts from the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(-2, 1) { |index| "new_#{index}" } # => ["a", "b", "new_2", "d"]
   #
   # If `start` is large (`start >= array.size`), extends `self` with `nil`:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(5, 0) { |index| "new_#{index}" } # => ["a", "b", "c", "d", nil]
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(5, 2) { |index| "new_#{index}" } # => ["a", "b", "c", "d", nil, "new_5", "new_6"]
   #
   # If `length` is zero or less, replaces no elements:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(1, 0) { |index| "new_#{index}" } # => ["a", "b", "c", "d"]
   #     a.fill(1, -1) { |index| "new_#{index}" } # => ["a", "b", "c", "d"]
@@ -1727,20 +1811,24 @@ class Array[unchecked out Elem] < Object
   #
   # If the range is positive and ascending (`range 0 < range.begin <= range.end`,
   # replaces elements from `range.begin` to `range.end`:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(1..1) { |index| "new_#{index}" } # => ["a", "new_1", "c", "d"]
   #
   # If `range.first` is negative, does nothing:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(-1..1) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]
   #
   # If `range.last` is negative, counts from the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(0..-2) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "d"]
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(1..-2) { |index| "new_#{index}" } # => ["a", "new_1", "new_2", "d"]
   #
   # If `range.first` and `range.last` are both negative, both count from the end:
+  #
   #     a = ['a', 'b', 'c', 'd']
   #     a.fill(-1..-1) { |index| "new_#{index}" } # => ["a", "b", "c", "new_3"]
   #     a = ['a', 'b', 'c', 'd']
@@ -1756,11 +1844,13 @@ class Array[unchecked out Elem] < Object
   # Calls the block, if given, with each element of `self`; returns a new Array
   # containing those elements of `self` for which the block returns a truthy
   # value:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a1 = a.select {|element| element.to_s.start_with?('b') }
   #     a1 # => ["bar", :bam]
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.select # => #<Enumerator: [:foo, "bar", 2, :bam]:select>
   #
@@ -1774,12 +1864,14 @@ class Array[unchecked out Elem] < Object
   # those elements for which the block returns `false` or `nil`.
   #
   # Returns `self` if any elements were removed:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.select! {|element| element.to_s.start_with?('b') } # => ["bar", :bam]
   #
   # Returns `nil` if no elements were removed.
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.select! # => #<Enumerator: [:foo, "bar", 2, :bam]:select!>
   #
@@ -1798,6 +1890,7 @@ class Array[unchecked out Elem] < Object
   #
   # When argument `object` is given but no block, returns the index of the first
   # element `element` for which `object == element`:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.index('bar') # => 1
   #
@@ -1806,12 +1899,14 @@ class Array[unchecked out Elem] < Object
   # When both argument `object` and a block are given, calls the block with each
   # successive element; returns the index of the first element for which the block
   # returns a truthy value:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.index {|element| element == 'bar' } # => 1
   #
   # Returns `nil` if the block never returns a truthy value.
   #
   # When neither an argument nor a block is given, returns a new Enumerator:
+  #
   #     a = [:foo, 'bar', 2]
   #     e = a.index
   #     e # => #<Enumerator: [:foo, "bar", 2]:index>
@@ -1833,6 +1928,7 @@ class Array[unchecked out Elem] < Object
   # Returns elements from `self`; does not modify `self`.
   #
   # When no argument is given, returns the first element:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.first # => :foo
   #     a # => [:foo, "bar", 2]
@@ -1841,14 +1937,17 @@ class Array[unchecked out Elem] < Object
   #
   # When non-negative Integer argument `n` is given, returns the first `n`
   # elements in a new Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.first(2) # => [:foo, "bar"]
   #
   # If `n >= array.size`, returns all elements:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.first(50) # => [:foo, "bar", 2]
   #
   # If `n == 0` returns an new empty Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.first(0) # []
   #
@@ -1869,6 +1968,7 @@ class Array[unchecked out Elem] < Object
   #
   # With non-negative Integer argument `level`, flattens recursively through
   # `level` levels:
+  #
   #     a = [ 0, [ 1, [2, 3], 4 ], 5 ]
   #     a.flatten(0) # => [0, [1, [2, 3], 4], 5]
   #     a = [ 0, [ 1, [2, 3], 4 ], 5 ]
@@ -1880,6 +1980,7 @@ class Array[unchecked out Elem] < Object
   #
   # With no argument, a `nil` argument, or with negative argument `level`,
   # flattens all levels:
+  #
   #     a = [ 0, [ 1, [2, 3], 4 ], 5 ]
   #     a.flatten # => [0, 1, 2, 3, 4, 5]
   #     [0, 1, 2].flatten # => [0, 1, 2]
@@ -1901,6 +2002,7 @@ class Array[unchecked out Elem] < Object
   #
   # With non-negative Integer argument `level`, flattens recursively through
   # `level` levels:
+  #
   #     a = [ 0, [ 1, [2, 3], 4 ], 5 ]
   #     a.flatten!(1) # => [0, 1, [2, 3], 4, 5]
   #     a = [ 0, [ 1, [2, 3], 4 ], 5 ]
@@ -1911,6 +2013,7 @@ class Array[unchecked out Elem] < Object
   #
   # With no argument, a `nil` argument, or with negative argument `level`,
   # flattens all levels:
+  #
   #     a = [ 0, [ 1, [2, 3], 4 ], 5 ]
   #     a.flatten! # => [0, 1, 2, 3, 4, 5]
   #     [0, 1, 2].flatten! # => nil
@@ -1930,6 +2033,7 @@ class Array[unchecked out Elem] < Object
   #
   # Two arrays with the same content will have the same hash code (and will
   # compare using eql?):
+  #
   #     [0, 1, 2].hash == [0, 1, 2].hash # => true
   #     [0, 1, 2].hash == [0, 1, 3].hash # => false
   #
@@ -1941,6 +2045,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns `true` if for some index `i` in `self`, `obj == self[i]`; otherwise
   # `false`:
+  #
   #     [0, 1, 2].include?(2) # => true
   #     [0, 1, 2].include?(3) # => false
   #
@@ -1951,6 +2056,7 @@ class Array[unchecked out Elem] < Object
   #
   # When argument `object` is given but no block, returns the index of the first
   # element `element` for which `object == element`:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.index('bar') # => 1
   #
@@ -1959,12 +2065,14 @@ class Array[unchecked out Elem] < Object
   # When both argument `object` and a block are given, calls the block with each
   # successive element; returns the index of the first element for which the block
   # returns a truthy value:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.index {|element| element == 'bar' } # => 1
   #
   # Returns `nil` if the block never returns a truthy value.
   #
   # When neither an argument nor a block is given, returns a new Enumerator:
+  #
   #     a = [:foo, 'bar', 2]
   #     e = a.index
   #     e # => #<Enumerator: [:foo, "bar", 2]:index>
@@ -1985,15 +2093,18 @@ class Array[unchecked out Elem] < Object
   #
   # When `index` is non-negative, inserts all given `objects` before the element
   # at offset `index`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.insert(1, :bat, :bam) # => [:foo, :bat, :bam, "bar", 2]
   #
   # Extends the array if `index` is beyond the array (`index >= self.size`):
+  #
   #     a = [:foo, 'bar', 2]
   #     a.insert(5, :bat, :bam)
   #     a # => [:foo, "bar", 2, nil, nil, :bat, :bam]
   #
   # Does nothing if no objects given:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.insert(1)
   #     a.insert(50)
@@ -2002,6 +2113,7 @@ class Array[unchecked out Elem] < Object
   #
   # When `index` is negative, inserts all given `objects` *after* the element at
   # offset `index+self.size`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.insert(-2, :bat, :bam)
   #     a # => [:foo, "bar", :bat, :bam, 2]
@@ -2014,6 +2126,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns the new String formed by calling method `#inspect` on each array
   # element:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.inspect # => "[:foo, \"bar\", 2]"
   #
@@ -2026,7 +2139,7 @@ class Array[unchecked out Elem] < Object
   #   - ary.intersect?(other_ary)   -> true or false
   # -->
   # Returns `true` if the array and `other_ary` have at least one element in
-  # common, otherwise returns `false`.
+  # common, otherwise returns `false`:
   #
   #     a = [ 1, 2, 3 ]
   #     b = [ 3, 4, 5 ]
@@ -2043,10 +2156,12 @@ class Array[unchecked out Elem] < Object
   # Returns a new Array containing each element found both in `self` and in all of
   # the given Arrays `other_arrays`; duplicates are omitted; items are compared
   # using `eql?`:
+  #
   #     [0, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3]) # => [0, 1]
   #     [0, 0, 1, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3]) # => [0, 1]
   #
   # Preserves order from `self`:
+  #
   #     [0, 1, 2].intersection([2, 1, 0]) # => [0, 1, 2]
   #
   # Returns a copy of `self` if no arguments given.
@@ -2061,22 +2176,26 @@ class Array[unchecked out Elem] < Object
   #   - array.join(separator = $,) -> new_string
   # -->
   # Returns the new String formed by joining the array elements after conversion.
-  # For each element `element`
+  # For each element `element`:
+  #
   # *   Uses `element.to_s` if `element` is not a `kind_of?(Array)`.
   # *   Uses recursive `element.join(separator)` if `element` is a
   #     `kind_of?(Array)`.
   #
   #
   # With no argument, joins using the output field separator, `$,`:
+  #
   #     a = [:foo, 'bar', 2]
   #     $, # => nil
   #     a.join # => "foobar2"
   #
   # With string argument `separator`, joins using that separator:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.join("\n") # => "foo\nbar\n2"
   #
   # Joins recursively for nested Arrays:
+  #
   #     a = [:foo, [:bar, [:baz, :bat]]]
   #     a.join # => "foobarbazbat"
   #
@@ -2089,10 +2208,12 @@ class Array[unchecked out Elem] < Object
   # -->
   # Retains those elements for which the block returns a truthy value; deletes all
   # other elements; returns `self`:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.keep_if {|element| element.to_s.start_with?('b') } # => ["bar", :bam]
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.keep_if # => #<Enumerator: [:foo, "bar", 2, :bam]:keep_if>
   #
@@ -2107,22 +2228,26 @@ class Array[unchecked out Elem] < Object
   # Returns elements from `self`; `self` is not modified.
   #
   # When no argument is given, returns the last element:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.last # => 2
   #     a # => [:foo, "bar", 2]
   #
   # If `self` is empty, returns `nil`.
   #
-  # When non-negative Innteger argument `n` is given, returns the last `n`
-  # elements in a new Array:
+  # When non-negative Integer argument `n` is given, returns the last `n` elements
+  # in a new Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.last(2) # => ["bar", 2]
   #
   # If `n >= array.size`, returns all elements:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.last(50) # => [:foo, "bar", 2]
   #
   # If `n == 0`, returns an new empty Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.last(0) # []
   #
@@ -2142,6 +2267,7 @@ class Array[unchecked out Elem] < Object
   # <!-- rdoc-file=array.c -->
   # Calls the block, if given, with each element of `self`; returns a new Array
   # whose elements are the return values from the block:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.map {|element| element.class }
   #     a1 # => [Symbol, String, Integer]
@@ -2158,10 +2284,12 @@ class Array[unchecked out Elem] < Object
   # <!-- rdoc-file=array.c -->
   # Calls the block, if given, with each element; replaces the element with the
   # block's return value:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.map! { |element| element.class } # => [Symbol, String, Integer]
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.map!
   #     a1 # => #<Enumerator: [:foo, "bar", 2]:map!>
@@ -2178,6 +2306,7 @@ class Array[unchecked out Elem] < Object
   #   - array.max(n) {|a, b| ... } -> new_array
   # -->
   # Returns one of the following:
+  #
   # *   The maximum-valued element from `self`.
   # *   A new Array of maximum-valued elements selected from `self`.
   #
@@ -2187,10 +2316,12 @@ class Array[unchecked out Elem] < Object
   #
   # With no argument and no block, returns the element in `self` having the
   # maximum value per method `<=>`:
+  #
   #     [0, 1, 2].max # => 2
   #
   # With an argument Integer `n` and no block, returns a new Array with at most
   # `n` elements, in descending order per method `<=>`:
+  #
   #     [0, 1, 2, 3].max(3) # => [3, 2, 1]
   #     [0, 1, 2, 3].max(6) # => [3, 2, 1, 0]
   #
@@ -2198,10 +2329,12 @@ class Array[unchecked out Elem] < Object
   #
   # With a block and no argument, calls the block `self.size-1` times to compare
   # elements; returns the element having the maximum value per the block:
+  #
   #     ['0', '00', '000'].max {|a, b| a.size <=> b.size } # => "000"
   #
   # With an argument `n` and a block, returns a new Array with at most `n`
   # elements, in descending order per the block:
+  #
   #     ['0', '00', '000'].max(2) {|a, b| a.size <=> b.size } # => ["000", "00"]
   #
   def max: () -> Elem?
@@ -2217,6 +2350,7 @@ class Array[unchecked out Elem] < Object
   #   - array.min(n) { |a, b| ... } -> new_array
   # -->
   # Returns one of the following:
+  #
   # *   The minimum-valued element from `self`.
   # *   A new Array of minimum-valued elements selected from `self`.
   #
@@ -2226,10 +2360,12 @@ class Array[unchecked out Elem] < Object
   #
   # With no argument and no block, returns the element in `self` having the
   # minimum value per method `<=>`:
+  #
   #     [0, 1, 2].min # => 0
   #
   # With Integer argument `n` and no block, returns a new Array with at most `n`
   # elements, in ascending order per method `<=>`:
+  #
   #     [0, 1, 2, 3].min(3) # => [0, 1, 2]
   #     [0, 1, 2, 3].min(6) # => [0, 1, 2, 3]
   #
@@ -2237,10 +2373,12 @@ class Array[unchecked out Elem] < Object
   #
   # With a block and no argument, calls the block `self.size-1` times to compare
   # elements; returns the element having the minimum value per the block:
+  #
   #     ['0', '00', '000'].min { |a, b| a.size <=> b.size } # => "0"
   #
   # With an argument `n` and a block, returns a new Array with at most `n`
   # elements, in ascending order per the block:
+  #
   #     ['0', '00', '000'].min(2) {|a, b| a.size <=> b.size } # => ["0", "00"]
   #
   alias min max
@@ -2256,11 +2394,13 @@ class Array[unchecked out Elem] < Object
   # When no block is given, each element in `self` must respond to method `<=>`
   # with an Integer; returns a new 2-element Array containing the minimum and
   # maximum values from `self`, per method `<=>`:
+  #
   #     [0, 1, 2].minmax # => [0, 2]
   #
   # When a block is given, the block must return an Integer; the block is called
   # `self.size-1` times to compare elements; returns a new 2-element Array
   # containing the minimum and maximum values from `self`, per the block:
+  #
   #     ['0', '00', '000'].minmax {|a, b| a.size <=> b.size } # => ["0", "000"]
   #
   def minmax: () -> [ Elem?, Elem? ]
@@ -2276,6 +2416,7 @@ class Array[unchecked out Elem] < Object
   #
   # With no block given and no argument, returns `true` if `self` has no truthy
   # elements, `false` otherwise:
+  #
   #     [nil, false].none? # => true
   #     [nil, 0, false].none? # => false
   #     [].none? # => true
@@ -2283,11 +2424,13 @@ class Array[unchecked out Elem] < Object
   # With a block given and no argument, calls the block with each element in
   # `self`; returns `true` if the block returns no truthy value, `false`
   # otherwise:
+  #
   #     [0, 1, 2].none? {|element| element > 3 } # => true
   #     [0, 1, 2].none? {|element| element > 1 } # => false
   #
   # If argument `obj` is given, returns `true` if `obj.===` no element, `false`
   # otherwise:
+  #
   #     ['food', 'drink'].none?(/bar/) # => true
   #     ['food', 'drink'].none?(/foo/) # => false
   #     [].none?(/foo/) # => true
@@ -2308,6 +2451,7 @@ class Array[unchecked out Elem] < Object
   #
   # With no block given and no argument, returns `true` if `self` has exactly one
   # truthy element, `false` otherwise:
+  #
   #     [nil, 0].one? # => true
   #     [0, 0].one? # => false
   #     [nil, nil].one? # => false
@@ -2316,12 +2460,14 @@ class Array[unchecked out Elem] < Object
   # With a block given and no argument, calls the block with each element in
   # `self`; returns `true` if the block a truthy value for exactly one element,
   # `false` otherwise:
+  #
   #     [0, 1, 2].one? {|element| element > 0 } # => false
   #     [0, 1, 2].one? {|element| element > 1 } # => true
   #     [0, 1, 2].one? {|element| element > 2 } # => false
   #
   # If argument `obj` is given, returns `true` if `obj.===` exactly one element,
   # `false` otherwise:
+  #
   #     [0, 1, 2].one?(0) # => true
   #     [0, 0, 1].one?(0) # => false
   #     [1, 1, 2].one?(0) # => false
@@ -2335,140 +2481,10 @@ class Array[unchecked out Elem] < Object
 
   # <!--
   #   rdoc-file=pack.rb
-  #   - arr.pack( aTemplateString ) -> aBinaryString
-  #   - arr.pack( aTemplateString, buffer: aBufferString ) -> aBufferString
-  # -->
-  # Packs the contents of *arr* into a binary sequence according to the directives
-  # in *aTemplateString* (see the table below) Directives ``A,'' ``a,'' and ``Z''
-  # may be followed by a count, which gives the width of the resulting field. The
-  # remaining directives also may take a count, indicating the number of array
-  # elements to convert. If the count is an asterisk (```*`''), all remaining
-  # array elements will be converted. Any of the directives ```sSiIlL`'' may be
-  # followed by an underscore (```_`'') or exclamation mark (```!`'') to use the
-  # underlying platform's native size for the specified type; otherwise, they use
-  # a platform-independent size. Spaces are ignored in the template string. See
-  # also String#unpack.
-  #
-  #     a = [ "a", "b", "c" ]
-  #     n = [ 65, 66, 67 ]
-  #     a.pack("A3A3A3")   #=> "a  b  c  "
-  #     a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
-  #     n.pack("ccc")      #=> "ABC"
-  #
-  # If *aBufferString* is specified and its capacity is enough, `pack` uses it as
-  # the buffer and returns it. When the offset is specified by the beginning of
-  # *aTemplateString*, the result is filled after the offset. If original contents
-  # of *aBufferString* exists and it's longer than the offset, the rest of
-  # *offsetOfBuffer* are overwritten by the result. If it's shorter, the gap is
-  # filled with ```\0`''.
-  #
-  #     # packed data is appended by default
-  #     [255].pack("C", buffer:"foo".b) #=> "foo\xFF"
-  #
-  #     # "@0" (offset 0) specifies that packed data is filled from beginning.
-  #     # Also, original data after packed data is removed. ("oo" is removed.)
-  #     [255].pack("@0C", buffer:"foo".b) #=> "\xFF"
-  #
-  #     # If the offset is bigger than the original length, \x00 is filled.
-  #     [255].pack("@5C", buffer:"foo".b) #=> "foo\x00\x00\xFF"
-  #
-  # Note that ``buffer:'' option does not guarantee not to allocate memory in
-  # `pack`.  If the capacity of *aBufferString* is not enough, `pack` allocates
-  # memory.
-  #
-  # Directives for `pack`.
-  #
-  #     Integer       | Array   |
-  #     Directive     | Element | Meaning
-  #     ----------------------------------------------------------------------------
-  #     C             | Integer | 8-bit unsigned (unsigned char)
-  #     S             | Integer | 16-bit unsigned, native endian (uint16_t)
-  #     L             | Integer | 32-bit unsigned, native endian (uint32_t)
-  #     Q             | Integer | 64-bit unsigned, native endian (uint64_t)
-  #     J             | Integer | pointer width unsigned, native endian (uintptr_t)
-  #                   |         | (J is available since Ruby 2.3.)
-  #                   |         |
-  #     c             | Integer | 8-bit signed (signed char)
-  #     s             | Integer | 16-bit signed, native endian (int16_t)
-  #     l             | Integer | 32-bit signed, native endian (int32_t)
-  #     q             | Integer | 64-bit signed, native endian (int64_t)
-  #     j             | Integer | pointer width signed, native endian (intptr_t)
-  #                   |         | (j is available since Ruby 2.3.)
-  #                   |         |
-  #     S_ S!         | Integer | unsigned short, native endian
-  #     I I_ I!       | Integer | unsigned int, native endian
-  #     L_ L!         | Integer | unsigned long, native endian
-  #     Q_ Q!         | Integer | unsigned long long, native endian (ArgumentError
-  #                   |         | if the platform has no long long type.)
-  #                   |         | (Q_ and Q! is available since Ruby 2.1.)
-  #     J!            | Integer | uintptr_t, native endian (same with J)
-  #                   |         | (J! is available since Ruby 2.3.)
-  #                   |         |
-  #     s_ s!         | Integer | signed short, native endian
-  #     i i_ i!       | Integer | signed int, native endian
-  #     l_ l!         | Integer | signed long, native endian
-  #     q_ q!         | Integer | signed long long, native endian (ArgumentError
-  #                   |         | if the platform has no long long type.)
-  #                   |         | (q_ and q! is available since Ruby 2.1.)
-  #     j!            | Integer | intptr_t, native endian (same with j)
-  #                   |         | (j! is available since Ruby 2.3.)
-  #                   |         |
-  #     S> s> S!> s!> | Integer | same as the directives without ">" except
-  #     L> l> L!> l!> |         | big endian
-  #     I!> i!>       |         | (available since Ruby 1.9.3)
-  #     Q> q> Q!> q!> |         | "S>" is the same as "n"
-  #     J> j> J!> j!> |         | "L>" is the same as "N"
-  #                   |         |
-  #     S< s< S!< s!< | Integer | same as the directives without "<" except
-  #     L< l< L!< l!< |         | little endian
-  #     I!< i!<       |         | (available since Ruby 1.9.3)
-  #     Q< q< Q!< q!< |         | "S<" is the same as "v"
-  #     J< j< J!< j!< |         | "L<" is the same as "V"
-  #                   |         |
-  #     n             | Integer | 16-bit unsigned, network (big-endian) byte order
-  #     N             | Integer | 32-bit unsigned, network (big-endian) byte order
-  #     v             | Integer | 16-bit unsigned, VAX (little-endian) byte order
-  #     V             | Integer | 32-bit unsigned, VAX (little-endian) byte order
-  #                   |         |
-  #     U             | Integer | UTF-8 character
-  #     w             | Integer | BER-compressed integer
-  #
-  #     Float        | Array   |
-  #     Directive    | Element | Meaning
-  #     ---------------------------------------------------------------------------
-  #     D d          | Float   | double-precision, native format
-  #     F f          | Float   | single-precision, native format
-  #     E            | Float   | double-precision, little-endian byte order
-  #     e            | Float   | single-precision, little-endian byte order
-  #     G            | Float   | double-precision, network (big-endian) byte order
-  #     g            | Float   | single-precision, network (big-endian) byte order
-  #
-  #     String       | Array   |
-  #     Directive    | Element | Meaning
-  #     ---------------------------------------------------------------------------
-  #     A            | String  | arbitrary binary string (space padded, count is width)
-  #     a            | String  | arbitrary binary string (null padded, count is width)
-  #     Z            | String  | same as ``a'', except that null is added with *
-  #     B            | String  | bit string (MSB first)
-  #     b            | String  | bit string (LSB first)
-  #     H            | String  | hex string (high nibble first)
-  #     h            | String  | hex string (low nibble first)
-  #     u            | String  | UU-encoded string
-  #     M            | String  | quoted printable, MIME encoding (see also RFC2045)
-  #                  |         | (text mode but input must use LF and output LF)
-  #     m            | String  | base64 encoded string (see RFC 2045)
-  #                  |         | (if count is 0, no line feed are added, see RFC 4648)
-  #                  |         | (count specifies input bytes between each LF,
-  #                  |         | rounded down to nearest multiple of 3)
-  #     P            | String  | pointer to a structure (fixed-length string)
-  #     p            | String  | pointer to a null-terminated string
-  #
-  #     Misc.        | Array   |
-  #     Directive    | Element | Meaning
-  #     ---------------------------------------------------------------------------
-  #     @            | ---     | moves to absolute position
-  #     X            | ---     | back up a byte
-  #     x            | ---     | null byte
+  #   - pack(template, buffer: nil) -> string
+  # -->
+  # Formats each element in `self` into a binary string; returns that string. See
+  # [Packed Data](rdoc-ref:packed_data.rdoc).
   #
   def pack: (string fmt, ?buffer: String?) -> String
 
@@ -2487,10 +2503,12 @@ class Array[unchecked out Elem] < Object
   # `self`.
   #
   # Example:
+  #
   #     a = [0, 1, 2]
   #     a.permutation(2) {|permutation| p permutation }
   #
   # Output:
+  #
   #     [0, 1]
   #     [0, 2]
   #     [1, 0]
@@ -2499,10 +2517,12 @@ class Array[unchecked out Elem] < Object
   #     [2, 1]
   #
   # Another example:
+  #
   #     a = [0, 1, 2]
   #     a.permutation(3) {|permutation| p permutation }
   #
   # Output:
+  #
   #     [0, 1, 2]
   #     [0, 2, 1]
   #     [1, 0, 2]
@@ -2511,24 +2531,29 @@ class Array[unchecked out Elem] < Object
   #     [2, 1, 0]
   #
   # When `n` is zero, calls the block once with a new empty Array:
+  #
   #     a = [0, 1, 2]
   #     a.permutation(0) {|permutation| p permutation }
   #
   # Output:
+  #
   #     []
   #
   # When `n` is out of range (negative or larger than `self.size`), does not call
   # the block:
+  #
   #     a = [0, 1, 2]
   #     a.permutation(-1) {|permutation| fail 'Cannot happen' }
   #     a.permutation(4) {|permutation| fail 'Cannot happen' }
   #
   # When a block given but no argument, behaves the same as
   # `a.permutation(a.size)`:
+  #
   #     a = [0, 1, 2]
   #     a.permutation {|permutation| p permutation }
   #
   # Output:
+  #
   #     [0, 1, 2]
   #     [0, 2, 1]
   #     [1, 0, 2]
@@ -2537,6 +2562,7 @@ class Array[unchecked out Elem] < Object
   #     [2, 1, 0]
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [0, 1, 2]
   #     a.permutation # => #<Enumerator: [0, 1, 2]:permutation>
   #     a.permutation(2) # => #<Enumerator: [0, 1, 2]:permutation(2)>
@@ -2553,18 +2579,21 @@ class Array[unchecked out Elem] < Object
   #
   # When no argument is given and `self` is not empty, removes and returns the
   # last element:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.pop # => 2
   #     a # => [:foo, "bar"]
   #
   # Returns `nil` if the array is empty.
   #
-  # When a non-negative Integer argument `n` is given and is in range, removes and
-  # returns the last `n` elements in a new Array:
+  # When a non-negative Integer argument `n` is given and is in range,
+  #
+  # removes and returns the last `n` elements in a new Array:
   #     a = [:foo, 'bar', 2]
   #     a.pop(2) # => ["bar", 2]
   #
   # If `n` is positive and out of range, removes and returns all elements:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.pop(50) # => [:foo, "bar", 2]
   #
@@ -2575,6 +2604,7 @@ class Array[unchecked out Elem] < Object
 
   # <!-- rdoc-file=array.c -->
   # Prepends the given `objects` to `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.unshift(:bam, :bat) # => [:bam, :bat, :foo, "bar", 2]
   #
@@ -2590,13 +2620,15 @@ class Array[unchecked out Elem] < Object
   #   - array.product(*other_arrays) {|combination| ... } -> self
   # -->
   # Computes and returns or yields all combinations of elements from all the
-  # Arrays, including both `self` and `other_arrays`.
+  # Arrays, including both `self` and `other_arrays`:
+  #
   # *   The number of combinations is the product of the sizes of all the arrays,
   #     including both `self` and `other_arrays`.
   # *   The order of the returned combinations is indeterminate.
   #
   #
   # When no block is given, returns the combinations as an Array of Arrays:
+  #
   #     a = [0, 1, 2]
   #     a1 = [3, 4]
   #     a2 = [5, 6]
@@ -2611,12 +2643,15 @@ class Array[unchecked out Elem] < Object
   #
   # If no argument is given, returns an Array of 1-element Arrays, each containing
   # an element of `self`:
+  #
   #     a.product # => [[0], [1], [2]]
   #
   # When a block is given, yields each combination as an Array; returns `self`:
+  #
   #     a.product(a1) {|combination| p combination }
   #
   # Output:
+  #
   #     [0, 3]
   #     [0, 4]
   #     [1, 3]
@@ -2625,12 +2660,15 @@ class Array[unchecked out Elem] < Object
   #     [2, 4]
   #
   # If any argument is an empty Array, does not call the block:
+  #
   #     a.product(a1, a2, []) {|combination| fail 'Cannot happen' }
   #
   # If no argument is given, yields each element of `self` as a 1-element Array:
+  #
   #     a.product {|combination| p combination }
   #
   # Output:
+  #
   #     [0]
   #     [1]
   #     [2]
@@ -2647,10 +2685,12 @@ class Array[unchecked out Elem] < Object
   # Appends trailing elements.
   #
   # Appends each argument in `objects` to `self`;  returns `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.push(:baz, :bat) # => [:foo, "bar", 2, :baz, :bat]
   #
   # Appends each argument as one element, even if it is another Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.push([:baz, :bat], [:bam, :bad])
   #     a1 # => [:foo, "bar", 2, [:baz, :bat], [:bam, :bad]]
@@ -2667,6 +2707,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns the first element in `self` that is an Array whose second element `==`
   # `obj`:
+  #
   #     a = [{foo: 0}, [2, 4], [4, 5, 6], [4, 5]]
   #     a.rassoc(4) # => [2, 4]
   #
@@ -2683,11 +2724,13 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns a new Array whose elements are all those from `self` for which the
   # block returns `false` or `nil`:
+  #
   #     a = [:foo, 'bar', 2, 'bat']
   #     a1 = a.reject {|element| element.to_s.start_with?('b') }
   #     a1 # => [:foo, 2]
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.reject # => #<Enumerator: [:foo, "bar", 2]:reject>
   #
@@ -2701,12 +2744,14 @@ class Array[unchecked out Elem] < Object
   # Removes each element for which the block returns a truthy value.
   #
   # Returns `self` if any elements removed:
+  #
   #     a = [:foo, 'bar', 2, 'bat']
   #     a.reject! {|element| element.to_s.start_with?('b') } # => [:foo, 2]
   #
   # Returns `nil` if no elements removed.
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.reject! # => #<Enumerator: [:foo, "bar", 2]:reject!>
   #
@@ -2727,18 +2772,22 @@ class Array[unchecked out Elem] < Object
   # of combinations is `(n+1)(n+2)/2`.
   #
   # `n` = 1:
+  #
   #     a = [0, 1, 2]
   #     a.repeated_combination(1) {|combination| p combination }
   #
   # Output:
+  #
   #     [0]
   #     [1]
   #     [2]
   #
   # `n` = 2:
+  #
   #     a.repeated_combination(2) {|combination| p combination }
   #
   # Output:
+  #
   #     [0, 0]
   #     [0, 1]
   #     [0, 2]
@@ -2749,14 +2798,17 @@ class Array[unchecked out Elem] < Object
   # If `n` is zero, calls the block once with an empty Array.
   #
   # If `n` is negative, does not call the block:
+  #
   #     a.repeated_combination(-1) {|combination| fail 'Cannot happen' }
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [0, 1, 2]
   #     a.repeated_combination(2) # => #<Enumerator: [0, 1, 2]:combination(2)>
   #
   # Using Enumerators, it's convenient to show the combinations and counts for
   # some values of `n`:
+  #
   #     e = a.repeated_combination(0)
   #     e.size # => 1
   #     e.to_a # => [[]]
@@ -2784,18 +2836,22 @@ class Array[unchecked out Elem] < Object
   # of permutations is `self.size**n`.
   #
   # `n` = 1:
+  #
   #     a = [0, 1, 2]
   #     a.repeated_permutation(1) {|permutation| p permutation }
   #
   # Output:
+  #
   #     [0]
   #     [1]
   #     [2]
   #
   # `n` = 2:
+  #
   #     a.repeated_permutation(2) {|permutation| p permutation }
   #
   # Output:
+  #
   #     [0, 0]
   #     [0, 1]
   #     [0, 2]
@@ -2809,14 +2865,17 @@ class Array[unchecked out Elem] < Object
   # If `n` is zero, calls the block once with an empty Array.
   #
   # If `n` is negative, does not call the block:
+  #
   #     a.repeated_permutation(-1) {|permutation| fail 'Cannot happen' }
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [0, 1, 2]
   #     a.repeated_permutation(2) # => #<Enumerator: [0, 1, 2]:permutation(2)>
   #
   # Using Enumerators, it's convenient to show the permutations and counts for
   # some values of `n`:
+  #
   #     e = a.repeated_permutation(0)
   #     e.size # => 1
   #     e.to_a # => [[]]
@@ -2833,6 +2892,7 @@ class Array[unchecked out Elem] < Object
   # <!-- rdoc-file=array.c -->
   # Replaces the content of `self` with the content of `other_array`; returns
   # `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.replace(['foo', :bar, 3]) # => ["foo", :bar, 3]
   #
@@ -2842,7 +2902,8 @@ class Array[unchecked out Elem] < Object
   #   rdoc-file=array.c
   #   - array.reverse -> new_array
   # -->
-  # Returns a new Array with the elements of `self` in reverse order.
+  # Returns a new Array with the elements of `self` in reverse order:
+  #
   #     a = ['foo', 'bar', 'two']
   #     a1 = a.reverse
   #     a1 # => ["two", "bar", "foo"]
@@ -2854,6 +2915,7 @@ class Array[unchecked out Elem] < Object
   #   - array.reverse! -> self
   # -->
   # Reverses `self` in place:
+  #
   #     a = ['foo', 'bar', 'two']
   #     a.reverse! # => ["two", "bar", "foo"]
   #
@@ -2868,29 +2930,35 @@ class Array[unchecked out Elem] < Object
   #
   # When a block given, passes, in reverse order, each element to the block;
   # returns `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.reverse_each {|element|  puts "#{element.class} #{element}" }
   #
   # Output:
+  #
   #     Integer 2
   #     String bar
   #     Symbol foo
   #
   # Allows the array to be modified during iteration:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.reverse_each {|element| puts element; a.clear if element.to_s.start_with?('b') }
   #
   # Output:
+  #
   #     2
   #     bar
   #
   # When no block given, returns a new Enumerator:
+  #
   #     a = [:foo, 'bar', 2]
   #     e = a.reverse_each
   #     e # => #<Enumerator: [:foo, "bar", 2]:reverse_each>
   #     a1 = e.each {|element|  puts "#{element.class} #{element}" }
   #
   # Output:
+  #
   #     Integer 2
   #     String bar
   #     Symbol foo
@@ -2910,6 +2978,7 @@ class Array[unchecked out Elem] < Object
   #
   # When argument `object` is given but no block, returns the index of the last
   # such element found:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.rindex('bar') # => 3
   #
@@ -2918,6 +2987,7 @@ class Array[unchecked out Elem] < Object
   # When a block is given but no argument, calls the block with each successive
   # element; returns the index of the last element for which the block returns a
   # truthy value:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.rindex {|element| element == 'bar' } # => 3
   #
@@ -2946,33 +3016,39 @@ class Array[unchecked out Elem] < Object
   #
   # When no argument given, returns a new Array that is like `self`, except that
   # the first element has been rotated to the last position:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a1 = a.rotate
   #     a1 # => ["bar", 2, "bar", :foo]
   #
   # When given a non-negative Integer `count`, returns a new Array with `count`
   # elements rotated from the beginning to the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.rotate(2)
   #     a1 # => [2, :foo, "bar"]
   #
   # If `count` is large, uses `count % array.size` as the count:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.rotate(20)
   #     a1 # => [2, :foo, "bar"]
   #
   # If `count` is zero, returns a copy of `self`, unmodified:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.rotate(0)
   #     a1 # => [:foo, "bar", 2]
   #
   # When given a negative Integer `count`, rotates in the opposite direction, from
   # end to beginning:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.rotate(-2)
   #     a1 # => ["bar", 2, :foo]
   #
   # If `count` is small (far from zero), uses `count % array.size` as the count:
+  #
   #     a = [:foo, 'bar', 2]
   #     a1 = a.rotate(-5)
   #     a1 # => ["bar", 2, :foo]
@@ -2988,32 +3064,38 @@ class Array[unchecked out Elem] < Object
   # `self`.
   #
   # When no argument given, rotates the first element to the last position:
+  #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.rotate! # => ["bar", 2, "bar", :foo]
   #
   # When given a non-negative Integer `count`, rotates `count` elements from the
   # beginning to the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.rotate!(2)
   #     a # => [2, :foo, "bar"]
   #
   # If `count` is large, uses `count % array.size` as the count:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.rotate!(20)
   #     a # => [2, :foo, "bar"]
   #
   # If `count` is zero, returns `self` unmodified:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.rotate!(0)
   #     a # => [:foo, "bar", 2]
   #
   # When given a negative Integer `count`, rotates in the opposite direction, from
   # end to beginning:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.rotate!(-2)
   #     a # => ["bar", 2, :foo]
   #
   # If `count` is small (far from zero), uses `count % array.size` as the count:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.rotate!(-5)
   #     a # => ["bar", 2, :foo]
@@ -3067,11 +3149,13 @@ class Array[unchecked out Elem] < Object
   # Calls the block, if given, with each element of `self`; returns a new Array
   # containing those elements of `self` for which the block returns a truthy
   # value:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a1 = a.select {|element| element.to_s.start_with?('b') }
   #     a1 # => ["bar", :bam]
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.select # => #<Enumerator: [:foo, "bar", 2, :bam]:select>
   #
@@ -3089,12 +3173,14 @@ class Array[unchecked out Elem] < Object
   # those elements for which the block returns `false` or `nil`.
   #
   # Returns `self` if any elements were removed:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.select! {|element| element.to_s.start_with?('b') } # => ["bar", :bam]
   #
   # Returns `nil` if no elements were removed.
   #
   # Returns a new Enumerator if no block given:
+  #
   #     a = [:foo, 'bar', 2, :bam]
   #     a.select! # => #<Enumerator: [:foo, "bar", 2, :bam]:select!>
   #
@@ -3111,6 +3197,7 @@ class Array[unchecked out Elem] < Object
   # Removes and returns leading elements.
   #
   # When no argument is given, removes and returns the first element:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.shift # => :foo
   #     a # => ['bar', 2]
@@ -3119,12 +3206,14 @@ class Array[unchecked out Elem] < Object
   #
   # When positive Integer argument `n` is given, removes the first `n` elements;
   # returns those elements in a new Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.shift(2) # => [:foo, 'bar']
   #     a # => [2]
   #
   # If `n` is as large as or larger than `self.length`, removes all elements;
   # returns those elements in a new Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.shift(3) # => [:foo, 'bar', 2]
   #
@@ -3173,12 +3262,14 @@ class Array[unchecked out Elem] < Object
   #
   # When a single Integer argument `index` is given, returns the element at offset
   # `index`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0] # => :foo
   #     a[2] # => 2
   #     a # => [:foo, "bar", 2]
   #
   # If `index` is negative, counts relative to the end of `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[-1] # => 2
   #     a[-2] # => "bar"
@@ -3187,12 +3278,14 @@ class Array[unchecked out Elem] < Object
   #
   # When two Integer arguments `start` and `length` are given, returns a new Array
   # of size `length` containing successive elements beginning at offset `start`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0, 2] # => [:foo, "bar"]
   #     a[1, 2] # => ["bar", 2]
   #
   # If `start + length` is greater than `self.length`, returns all elements from
   # offset `start` to the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0, 4] # => [:foo, "bar", 2]
   #     a[1, 3] # => ["bar", 2]
@@ -3204,6 +3297,7 @@ class Array[unchecked out Elem] < Object
   #
   # When a single Range argument `range` is given, treats `range.min` as `start`
   # above and `range.size` as `length` above:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0..1] # => [:foo, "bar"]
   #     a[1..2] # => ["bar", 2]
@@ -3211,18 +3305,21 @@ class Array[unchecked out Elem] < Object
   # Special case: If `range.start == a.size`, returns a new empty Array.
   #
   # If `range.end` is negative, calculates the end index from the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[0..-1] # => [:foo, "bar", 2]
   #     a[0..-2] # => [:foo, "bar"]
   #     a[0..-3] # => [:foo]
   #
   # If `range.start` is negative, calculates the start index from the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a[-1..2] # => [2]
   #     a[-2..2] # => ["bar", 2]
   #     a[-3..2] # => [:foo, "bar", 2]
   #
   # If `range.start` is larger than the array size, returns `nil`.
+  #
   #     a = [:foo, 'bar', 2]
   #     a[4..1] # => nil
   #     a[4..0] # => nil
@@ -3230,11 +3327,13 @@ class Array[unchecked out Elem] < Object
   #
   # When a single Enumerator::ArithmeticSequence argument `aseq` is given, returns
   # an Array of elements corresponding to the indexes produced by the sequence.
+  #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..).step(2)] # => ["data1", "data2", "data3"]
   #
   # Unlike slicing with range, if the start or the end of the arithmetic sequence
   # is larger than array size, throws RangeError.
+  #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..11).step(2)]
   #     # RangeError (((1..11).step(2)) out of range)
@@ -3243,6 +3342,7 @@ class Array[unchecked out Elem] < Object
   #
   # If given a single argument, and its type is not one of the listed, tries to
   # convert it to Integer, and raises if it is impossible:
+  #
   #     a = [:foo, 'bar', 2]
   #     # Raises TypeError (no implicit conversion of Symbol into Integer):
   #     a[:foo]
@@ -3263,11 +3363,13 @@ class Array[unchecked out Elem] < Object
   #
   # When the only argument is an Integer `n`, removes and returns the *nth*
   # element in `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.slice!(1) # => "bar"
   #     a # => [:foo, 2]
   #
   # If `n` is negative, counts backwards from the end of `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.slice!(-1) # => 2
   #     a # => [:foo, "bar"]
@@ -3277,12 +3379,14 @@ class Array[unchecked out Elem] < Object
   # When the only arguments are Integers `start` and `length`, removes `length`
   # elements from `self` beginning at offset  `start`; returns the deleted objects
   # in a new Array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.slice!(0, 2) # => [:foo, "bar"]
   #     a # => [2]
   #
   # If `start + length` exceeds the array size, removes and returns all elements
   # from offset `start` to the end:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.slice!(1, 50) # => ["bar", 2]
   #     a # => [:foo]
@@ -3293,8 +3397,9 @@ class Array[unchecked out Elem] < Object
   #
   # When the only argument is a Range object `range`, treats `range.min` as
   # `start` above and `range.size` as `length` above:
+  #
   #     a = [:foo, 'bar', 2]
-  #      a.slice!(1..2) # => ["bar", 2]
+  #     a.slice!(1..2) # => ["bar", 2]
   #     a # => [:foo]
   #
   # If `range.start == a.size`, returns a new empty Array.
@@ -3302,12 +3407,14 @@ class Array[unchecked out Elem] < Object
   # If `range.start` is larger than the array size, returns `nil`.
   #
   # If `range.end` is negative, counts backwards from the end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.slice!(0..-2) # => [:foo, "bar"]
   #     a # => [2]
   #
   # If `range.start` is negative, calculates the start index backwards from the
   # end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.slice!(-2..2) # => ["bar", 2]
   #     a # => [:foo]
@@ -3324,6 +3431,7 @@ class Array[unchecked out Elem] < Object
   # Returns a new Array whose elements are those from `self`, sorted.
   #
   # With no block, compares elements using operator `<=>` (see Comparable):
+  #
   #     a = 'abcde'.split('').shuffle
   #     a # => ["e", "b", "d", "a", "c"]
   #     a1 = a.sort
@@ -3331,12 +3439,14 @@ class Array[unchecked out Elem] < Object
   #
   # With a block, calls the block with each element pair; for each element pair
   # `a` and `b`, the block should return an integer:
+  #
   # *   Negative when `b` is to follow `a`.
   # *   Zero when `a` and `b` are equivalent.
   # *   Positive when `a` is to follow `b`.
   #
   #
   # Example:
+  #
   #     a = 'abcde'.split('').shuffle
   #     a # => ["e", "b", "d", "a", "c"]
   #     a1 = a.sort {|a, b| a <=> b }
@@ -3346,6 +3456,7 @@ class Array[unchecked out Elem] < Object
   #
   # When the block returns zero, the order for `a` and `b` is indeterminate, and
   # may be unstable:
+  #
   #     a = 'abcde'.split('').shuffle
   #     a # => ["e", "b", "d", "a", "c"]
   #     a1 = a.sort {|a, b| 0 }
@@ -3364,6 +3475,7 @@ class Array[unchecked out Elem] < Object
   # Returns `self` with its elements sorted in place.
   #
   # With no block, compares elements using operator `<=>` (see Comparable):
+  #
   #     a = 'abcde'.split('').shuffle
   #     a # => ["e", "b", "d", "a", "c"]
   #     a.sort!
@@ -3371,12 +3483,14 @@ class Array[unchecked out Elem] < Object
   #
   # With a block, calls the block with each element pair; for each element pair
   # `a` and `b`, the block should return an integer:
+  #
   # *   Negative when `b` is to follow `a`.
   # *   Zero when `a` and `b` are equivalent.
   # *   Positive when `a` is to follow `b`.
   #
   #
   # Example:
+  #
   #     a = 'abcde'.split('').shuffle
   #     a # => ["e", "b", "d", "a", "c"]
   #     a.sort! {|a, b| a <=> b }
@@ -3386,6 +3500,7 @@ class Array[unchecked out Elem] < Object
   #
   # When the block returns zero, the order for `a` and `b` is indeterminate, and
   # may be unstable:
+  #
   #     a = 'abcde'.split('').shuffle
   #     a # => ["e", "b", "d", "a", "c"]
   #     a.sort! {|a, b| 0 }
@@ -3409,6 +3524,7 @@ class Array[unchecked out Elem] < Object
   # be unstable.
   #
   # This example sorts strings based on their sizes:
+  #
   #     a = ['aaaa', 'bbb', 'cc', 'd']
   #     a.sort_by! {|element| element.size }
   #     a # => ["d", "cc", "bbb", "aaaa"]
@@ -3427,6 +3543,7 @@ class Array[unchecked out Elem] < Object
   #   - array.sum(init = 0) {|element| ... } -> object
   # -->
   # When no block is given, returns the object equivalent to:
+  #
   #     sum = init
   #     array.each {|element| sum += element }
   #     sum
@@ -3434,22 +3551,26 @@ class Array[unchecked out Elem] < Object
   # For example, `[e1, e2, e3].sum` returns `init + e1 + e2 + e3`.
   #
   # Examples:
+  #
   #     a = [0, 1, 2, 3]
   #     a.sum # => 6
   #     a.sum(100) # => 106
   #
   # The elements need not be numeric, but must be `+`-compatible with each other
   # and with `init`:
+  #
   #     a = ['abc', 'def', 'ghi']
   #     a.sum('jkl') # => "jklabcdefghi"
   #
   # When a block is given, it is called with each element and the block's return
   # value (instead of the element itself) is used as the addend:
+  #
   #     a = ['zero', 1, :two]
   #     s = a.sum('Coerced and concatenated: ') {|element| element.to_s }
   #     s # => "Coerced and concatenated: zero1two"
   #
   # Notes:
+  #
   # *   Array#join and Array#flatten may be faster than Array#sum for an Array of
   #     Strings or an Array of Arrays.
   # *   Array#sum method may not respect method redefinition of "+" methods such
@@ -3466,6 +3587,7 @@ class Array[unchecked out Elem] < Object
   # non-negative Integer; does not modify `self`.
   #
   # Examples:
+  #
   #     a = [0, 1, 2, 3, 4, 5]
   #     a.take(1) # => [0]
   #     a.take(2) # => [0, 1]
@@ -3485,12 +3607,14 @@ class Array[unchecked out Elem] < Object
   # With a block given, calls the block with each successive element of `self`;
   # stops if the block returns `false` or `nil`; returns a new Array containing
   # those elements for which the block returned a truthy value:
+  #
   #     a = [0, 1, 2, 3, 4, 5]
   #     a.take_while {|element| element < 3 } # => [0, 1, 2]
   #     a.take_while {|element| true } # => [0, 1, 2, 3, 4, 5]
   #     a # => [0, 1, 2, 3, 4, 5]
   #
   # With no block given, returns a new Enumerator:
+  #
   #     [0, 1].take_while # => #<Enumerator: [0, 1]:take_while>
   #
   def take_while: () { (Elem obj) -> boolish } -> ::Array[Elem]
@@ -3501,10 +3625,12 @@ class Array[unchecked out Elem] < Object
   #   - to_a -> self or new_array
   # -->
   # When `self` is an instance of Array, returns `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.to_a # => [:foo, "bar", 2]
   #
   # Otherwise, returns a new Array containing the elements of `self`:
+  #
   #     class MyArray < Array; end
   #     a = MyArray.new(['foo', 'bar', 'two'])
   #     a.instance_of?(Array) # => false
@@ -3533,12 +3659,14 @@ class Array[unchecked out Elem] < Object
   # When a block is given, calls the block with each array element; the block must
   # return a 2-element Array whose two elements form a key-value pair in the
   # returned Hash:
+  #
   #     a = ['foo', :bar, 1, [2, 3], {baz: 4}]
   #     h = a.to_h {|item| [item, item] }
   #     h # => {"foo"=>"foo", :bar=>:bar, 1=>1, [2, 3]=>[2, 3], {:baz=>4}=>{:baz=>4}}
   #
   # When no block is given, `self` must be an Array of 2-element sub-arrays, each
   # sub-array is formed into a key-value pair in the new Hash:
+  #
   #     [].to_h # => {}
   #     a = [['foo', 'zero'], ['bar', 'one'], ['baz', 'two']]
   #     h = a.to_h
@@ -3550,6 +3678,7 @@ class Array[unchecked out Elem] < Object
   # <!-- rdoc-file=array.c -->
   # Returns the new String formed by calling method `#inspect` on each array
   # element:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.inspect # => "[:foo, \"bar\", 2]"
   #
@@ -3563,6 +3692,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Transposes the rows and columns in an Array of Arrays; the nested Arrays must
   # all be the same size:
+  #
   #     a = [[:a0, :a1], [:b0, :b1], [:c0, :c1]]
   #     a.transpose # => [[:a0, :b0, :c0], [:a1, :b1, :c1]]
   #
@@ -3575,6 +3705,7 @@ class Array[unchecked out Elem] < Object
   # Returns a new Array that is the union of `self` and all given Arrays
   # `other_arrays`; duplicates are removed;  order is preserved;  items are
   # compared using `eql?`:
+  #
   #     [0, 1, 2, 3].union([4, 5], [6, 7]) # => [0, 1, 2, 3, 4, 5, 6, 7]
   #     [0, 1, 1].union([2, 1], [3, 1]) # => [0, 1, 2, 3]
   #     [0, 1, 2, 3].union([3, 2], [1, 0]) # => [0, 1, 2, 3]
@@ -3594,13 +3725,15 @@ class Array[unchecked out Elem] < Object
   # duplicates, the first occurrence always being retained.
   #
   # With no block given, identifies and omits duplicates using method `eql?` to
-  # compare.
+  # compare:
+  #
   #     a = [0, 0, 1, 1, 2, 2]
   #     a.uniq # => [0, 1, 2]
   #
   # With a block given, calls the block for each element; identifies (using method
   # `eql?`) and omits duplicate values, that is, those elements for which the
   # block returns the same value:
+  #
   #     a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb']
   #     a.uniq {|element| element.size } # => ["a", "aa", "aaa"]
   #
@@ -3619,6 +3752,7 @@ class Array[unchecked out Elem] < Object
   # compare.
   #
   # Returns `self` if any elements removed:
+  #
   #     a = [0, 0, 1, 1, 2, 2]
   #     a.uniq! # => [0, 1, 2]
   #
@@ -3628,6 +3762,7 @@ class Array[unchecked out Elem] < Object
   # `eql?`) and removes elements for which the block returns duplicate values.
   #
   # Returns `self` if any elements removed:
+  #
   #     a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb']
   #     a.uniq! {|element| element.size } # => ['a', 'aa', 'aaa']
   #
@@ -3641,6 +3776,7 @@ class Array[unchecked out Elem] < Object
   #   - array.unshift(*objects) -> self
   # -->
   # Prepends the given `objects` to `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.unshift(:bam, :bat) # => [:bam, :bat, :foo, "bar", 2]
   #
@@ -3658,30 +3794,36 @@ class Array[unchecked out Elem] < Object
   # Integer or Range `indexes`.
   #
   # For each positive `index`, returns the element at offset `index`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.values_at(0, 2) # => [:foo, 2]
   #     a.values_at(0..1) # => [:foo, "bar"]
   #
   # The given `indexes` may be in any order, and may repeat:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.values_at(2, 0, 1, 0, 2) # => [2, :foo, "bar", :foo, 2]
   #     a.values_at(1, 0..2) # => ["bar", :foo, "bar", 2]
   #
   # Assigns `nil` for an `index` that is too large:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.values_at(0, 3, 1, 3) # => [:foo, nil, "bar", nil]
   #
   # Returns a new empty Array if no arguments given.
   #
   # For each negative `index`, counts backward from the end of the array:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.values_at(-1, -3) # => [2, :foo]
   #
   # Assigns `nil` for an `index` that is too small:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.values_at(0, -5, 1, -6, 2) # => [:foo, nil, "bar", nil, 2]
   #
   # The given `indexes` may have a mixture of signs:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.values_at(0, -2, 1, -1) # => [:foo, "bar", "bar", 2]
   #
@@ -3697,11 +3839,13 @@ class Array[unchecked out Elem] < Object
   #
   # Each nested array `new_array[n]` is of size `other_arrays.size+1`, and
   # contains:
+  #
   # *   The *nth* element of `self`.
   # *   The *nth* element of each of the `other_arrays`.
   #
   #
   # If all `other_arrays` and `self` are the same size:
+  #
   #     a = [:a0, :a1, :a2, :a3]
   #     b = [:b0, :b1, :b2, :b3]
   #     c = [:c0, :c1, :c2, :c3]
@@ -3710,6 +3854,7 @@ class Array[unchecked out Elem] < Object
   #
   # If any array in `other_arrays` is smaller than `self`, fills to `self.size`
   # with `nil`:
+  #
   #     a = [:a0, :a1, :a2, :a3]
   #     b = [:b0, :b1, :b2]
   #     c = [:c0, :c1]
@@ -3718,6 +3863,7 @@ class Array[unchecked out Elem] < Object
   #
   # If any array in `other_arrays` is larger than `self`, its trailing elements
   # are ignored:
+  #
   #     a = [:a0, :a1, :a2, :a3]
   #     b = [:b0, :b1, :b2, :b3, :b4]
   #     c = [:c0, :c1, :c2, :c3, :c4, :c5]
@@ -3725,22 +3871,24 @@ class Array[unchecked out Elem] < Object
   #     d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]
   #
   # When a block is given, calls the block with each of the sub-arrays (formed as
-  # above); returns nil
+  # above); returns `nil`:
+  #
   #     a = [:a0, :a1, :a2, :a3]
   #     b = [:b0, :b1, :b2, :b3]
   #     c = [:c0, :c1, :c2, :c3]
   #     a.zip(b, c) {|sub_array| p sub_array} # => nil
   #
   # Output:
+  #
   #     [:a0, :b0, :c0]
   #     [:a1, :b1, :c1]
   #     [:a2, :b2, :c2]
   #     [:a3, :b3, :c3]
   #
-  def zip: [U] (::Array[U] arg) -> ::Array[[ Elem, U? ]]
-         | (::Array[untyped] arg, *::Array[untyped] args) -> ::Array[::Array[untyped]]
-         | [U] (::Array[U] arg) { ([ Elem, U? ]) -> void } -> void
-         | (::Array[untyped] arg, *::Array[untyped] args) { (::Array[untyped]) -> void } -> void
+  def zip: [U] (_Each[U] arg) -> Array[[ Elem, U? ]]
+         | (_Each[untyped] arg, *_Each[untyped] args) -> Array[Array[untyped]]
+         | [U] (_Each[U] arg) { ([ Elem, U? ]) -> void } -> nil
+         | (_Each[untyped] arg, *_Each[untyped] args) { (Array[untyped]) -> void } -> nil
 
   # <!--
   #   rdoc-file=array.c
@@ -3748,6 +3896,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns the union of `array` and Array `other_array`; duplicates are removed;
   # order is preserved; items are compared using `eql?`:
+  #
   #     [0, 1] | [2, 3] # => [0, 1, 2, 3]
   #     [0, 1, 1] | [2, 2, 3] # => [0, 1, 2, 3]
   #     [0, 1, 2] | [3, 2, 1, 0] # => [0, 1, 2, 3]
@@ -3764,6 +3913,7 @@ class Array[unchecked out Elem] < Object
   # -->
   # Replaces the content of `self` with the content of `other_array`; returns
   # `self`:
+  #
   #     a = [:foo, 'bar', 2]
   #     a.replace(['foo', :bar, 3]) # => ["foo", :bar, 3]
   #