rbs 3.9.4 → 4.1.1

data/core/array.rbs

@@ -151,8 +151,8 @@
 #
 # ## Example Usage
 #
-# In addition to the methods it mixes in through the Enumerable module, the
-# `Array` class has proprietary methods for accessing, searching and otherwise
+# In addition to the methods it mixes in through the Enumerable module, class
+# Array has proprietary methods for accessing, searching and otherwise
 # manipulating arrays.
 #
 # Some of the more common ones are illustrated below.
@@ -200,9 +200,9 @@
 #
 #     arr.drop(3) #=> [4, 5, 6]
 #
-# ## Obtaining Information about an `Array`
+# ## Obtaining Information about an Array
 #
-# Arrays keep track of their own length at all times.  To query an array about
+# An array keeps track of its own length at all times.  To query an array about
 # the number of elements it contains, use #length, #count or #size.
 #
 #     browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE']
@@ -217,7 +217,7 @@
 #
 #     browsers.include?('Konqueror') #=> false
 #
-# ## Adding Items to Arrays
+# ## Adding Items to an Array
 #
 # Items can be added to the end of an array by using either #push or #<<
 #
@@ -238,7 +238,7 @@
 #     arr.insert(3, 'orange', 'pear', 'grapefruit')
 #     #=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]
 #
-# ## Removing Items from an `Array`
+# ## Removing Items from an Array
 #
 # The method #pop removes the last element in an array and returns it:
 #
@@ -277,12 +277,12 @@
 #     arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
 #     arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]
 #
-# ## Iterating over Arrays
+# ## Iterating over an Array
 #
-# Like all classes that include the Enumerable module, `Array` has an each
+# Like all classes that include the Enumerable module, class Array has an each
 # method, which defines what elements should be iterated over and how.  In case
-# of Array's #each, all elements in the `Array` instance are yielded to the
-# supplied block in sequence.
+# of Array#each, all elements in `self` are yielded to the supplied block in
+# sequence.
 #
 # Note that this operation leaves the array unchanged.
 #
@@ -307,7 +307,7 @@
 #     arr.map! {|a| a**2}   #=> [1, 4, 9, 16, 25]
 #     arr                   #=> [1, 4, 9, 16, 25]
 #
-# ## Selecting Items from an `Array`
+# ## Selecting Items from an Array
 #
 # Elements can be selected from an array according to criteria defined in a
 # block.  The selection can happen in a destructive or a non-destructive manner.
@@ -340,13 +340,13 @@
 #
 # ## What's Here
 #
-# First, what's elsewhere. Class `Array`:
+# First, what's elsewhere. Class Array:
 #
 # *   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:
+# Here, class Array provides methods that are useful for:
 #
 # *   [Creating an Array](rdoc-ref:Array@Methods+for+Creating+an+Array)
 # *   [Querying](rdoc-ref:Array@Methods+for+Querying)
@@ -359,7 +359,7 @@
 # *   [Converting](rdoc-ref:Array@Methods+for+Converting)
 # *   [And more....](rdoc-ref:Array@Other+Methods)
 #
-# ### Methods for Creating an `Array`
+# ### Methods for Creating an Array
 #
 # *   ::[]: Returns a new array populated with given objects.
 # *   ::new: Returns a new array.
@@ -376,10 +376,10 @@
 # *   #find_index (aliased as #index): Returns the index of the first element
 #     that meets a given criterion.
 # *   #hash: Returns the integer hash code.
-# *   #include?: Returns whether any element `==` a given object.
+# *   #include?: Returns whether any element <code>==</code> a given object.
 # *   #length (aliased as #size): Returns the count of elements.
-# *   #none?: Returns whether no element `==` a given object.
-# *   #one?: Returns whether exactly one element `==` a given object.
+# *   #none?: Returns whether no element <code>==</code> a given object.
+# *   #one?: Returns whether exactly one element <code>==</code> a given object.
 # *   #rindex: Returns the index of the last element that meets a given
 #     criterion.
 #
@@ -387,9 +387,9 @@
 #
 # *   #<=>: 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
+# *   #==: Returns whether each element in `self` is <code>==</code> to the
+#     corresponding element in a given object.
+# *   #eql?: Returns whether each element in `self` is <code>eql?</code> to the
 #     corresponding element in a given object.
 #
 # ### Methods for Fetching
@@ -399,7 +399,7 @@
 # *   #[] (aliased as #slice): Returns consecutive elements as determined by a
 #     given argument.
 # *   #assoc: Returns the first element that is an array whose first element
-#     `==` a given object.
+#     <code>==</code> a given object.
 # *   #at: Returns the element at a given offset.
 # *   #bsearch: Returns an element selected via a binary search as determined by
 #     a given block.
@@ -414,14 +414,14 @@
 # *   #fetch_values: Returns elements at given offsets.
 # *   #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.
+# *   #max: Returns one or more maximum-valued elements, as determined by
+#     <code>#<=></code> or a given block.
+# *   #min: Returns one or more minimum-valued elements, as determined by
+#     <code>#<=></code> or a given block.
 # *   #minmax: Returns the minimum-valued and maximum-valued elements, as
-#     determined by `#<=>` or a given block.
+#     determined by <code>#<=></code> or a given block.
 # *   #rassoc: Returns the first element that is an array whose second element
-#     `==` a given object.
+#     <code>==</code> a given object.
 # *   #reject: Returns an array containing elements not rejected by a given
 #     block.
 # *   #reverse: Returns all elements in reverse order.
@@ -430,8 +430,8 @@
 # *   #select (aliased as #filter): Returns an array containing elements
 #     selected by a given block.
 # *   #shuffle: Returns elements in a random order.
-# *   #sort: Returns all elements in an order determined by `#<=>` or a given
-#     block.
+# *   #sort: Returns all elements in an order determined by <code>#<=></code> or
+#     a given block.
 # *   #take: Returns leading elements as determined by a given index.
 # *   #take_while: Returns leading elements as determined by a given block.
 # *   #uniq: Returns an array containing non-duplicate elements.
@@ -455,8 +455,8 @@
 # *   #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!: Replaces `self` with its elements sorted, as determined by
+#     <code>#<=></code> or a given block.
 # *   #sort_by!: Replaces `self` with its elements sorted, as determined by a
 #     given block.
 # *   #unshift (aliased as #prepend): Prepends leading elements.
@@ -524,7 +524,7 @@
 #     return-value.
 # *   #flatten: Returns an array that is a recursive flattening of `self`.
 # *   #inspect (aliased as #to_s): Returns a new String containing the elements.
-# *   #join: Returns a newsString containing the elements joined by the field
+# *   #join: Returns a new String containing the elements joined by the field
 #     separator.
 # *   #to_a: Returns `self` or a new array containing all elements.
 # *   #to_ary: Returns `self`.
@@ -539,14 +539,21 @@
 #     *   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)`.
+#         equivalent to <code>join(field_separator)</code>.
 #
 # *   #pack: Packs the elements into a binary sequence.
-# *   #sum: Returns a sum of elements according to either `+` or a given block.
+# *   #sum: Returns a sum of elements according to either <code>+</code> or a
+#     given block.
 #
 %a{annotate:rdoc:source:from=array.c}
-class Array[unchecked out Elem] < Object
-  include Enumerable[Elem]
+class Array[unchecked out E]
+  include Enumerable[E]
+
+  # Interface for random number generations; used with `Array#shuffle`, `Array#shuffle!`, and `Array#sample`.
+  interface _Rand
+    # Generate a random number up to, but excluding, `max`
+    def rand: (Integer max) -> int
+  end
 
   # <!--
   #   rdoc-file=array.c
@@ -574,8 +581,8 @@ class Array[unchecked out Elem] < Object
   #     Array.new(2, 3) # => [3, 3]
   #
   # With a block given, returns an array of the given `size`; calls the block with
-  # each `index` in the range `(0...size)`; the element at that `index` in the
-  # returned array is the blocks return value:
+  # each `index` in the range <code>(0...size)</code>; the element at that `index`
+  # in the returned array is the blocks return value:
   #
   #     Array.new(3)  {|index| "Element #{index}" } # => ["Element 0", "Element 1", "Element 2"]
   #
@@ -603,9 +610,9 @@ class Array[unchecked out Elem] < Object
   # Array](rdoc-ref:Array@Methods+for+Creating+an+Array).
   #
   def initialize: () -> void
-                | (::Array[Elem] ary) -> void
-                | (int size, ?Elem val) -> void
-                | (int size) { (::Integer index) -> Elem } -> void
+                | (array[E] array) -> void
+                | (int size, ?E default_value) -> void
+                | (int size) { (Integer index) -> E } -> void
 
   # <!--
   #   rdoc-file=array.c
@@ -620,7 +627,7 @@ class Array[unchecked out Elem] < Object
   # Related: see [Methods for Creating an
   # Array](rdoc-ref:Array@Methods+for+Creating+an+Array).
   #
-  def self.[]: [U] (*U) -> ::Array[U]
+  def self.[]: [U] (*U) -> Array[U] # this technically returns a subclass, but `instance(self)` isn't a thing
 
   # <!--
   #   rdoc-file=array.c
@@ -630,16 +637,18 @@ class Array[unchecked out Elem] < Object
   #
   # If `object` is an array, returns `object`.
   #
-  # Otherwise if `object` responds to `:to_ary`. calls `object.to_ary`: if the
-  # return value is an array or `nil`, returns that value; if not, raises
-  # TypeError.
+  # Otherwise if `object` responds to <code>:to_ary</code>. calls
+  # <code>object.to_ary</code>: if the return value is an array or `nil`, returns
+  # that value; if not, raises TypeError.
   #
   # Otherwise returns `nil`.
   #
   # Related: see [Methods for Creating an
   # Array](rdoc-ref:Array@Methods+for+Creating+an+Array).
   #
-  def self.try_convert: [U] (untyped) -> ::Array[U]?
+  def self.try_convert: [A < Array[U], U] (A array) -> A
+                      | [U] (array[U] ary) -> Array[U]?
+                      | (untyped) -> Array[untyped]?
 
   # <!--
   #   rdoc-file=array.c
@@ -658,12 +667,12 @@ class Array[unchecked out Elem] < Object
   #
   #     [0, 1, 2] & [3, 2, 1, 0] # => [0, 1, 2]
   #
-  # Identifies common elements using method `#eql?` (as defined in each element of
-  # `self`).
+  # Identifies common elements using method <code>#eql?</code> (as defined in each
+  # element of `self`).
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def &: (::Array[untyped] | _ToAry[untyped]) -> ::Array[Elem]
+  def &: (array[untyped] other_array) -> Array[E] # where E: _Eql?[T]
 
   # <!--
   #   rdoc-file=array.c
@@ -677,12 +686,12 @@ class Array[unchecked out Elem] < Object
   #     a * 3 # => ["x", "y", "x", "y", "x", "y"]
   #
   # When string argument `string_separator` is given, equivalent to
-  # `self.join(string_separator)`:
+  # <code>self.join(string_separator)</code>:
   #
   #     [0, [0, 1], {foo: 0}] * ', ' # => "0, 0, 1, {foo: 0}"
   #
-  def *: (string str) -> ::String
-       | (int int) -> ::Array[Elem]
+  def *: (string string_separator) -> String # where E: _ToS
+       | (int n) -> Array[E] # where E: _ToS
 
   # <!--
   #   rdoc-file=array.c
@@ -696,7 +705,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def +: [U] (_ToAry[U]) -> ::Array[Elem | U]
+  def +: [U] (array[U] other_array) -> Array[E | U]
 
   # <!--
   #   rdoc-file=array.c
@@ -709,12 +718,12 @@ class Array[unchecked out Elem] < Object
   #     [0, 1, 1, 2, 1, 1, 3, 1, 1] - [3, 2, 0, :foo] # => [1, 1, 1, 1, 1, 1]
   #     [0, 1, 2] - [:foo]                            # => [0, 1, 2]
   #
-  # Element are compared using method `#eql?` (as defined in each element of
-  # `self`).
+  # Element are compared using method <code>#eql?</code> (as defined in each
+  # element of `self`).
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def -: (_ToAry[untyped]) -> ::Array[Elem]
+  def -: (array[untyped] other_array) -> Array[E] # where E: _Eql?[T]
 
   # <!--
   #   rdoc-file=array.c
@@ -730,7 +739,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def <<: (Elem) -> self
+  def <<: (E object) -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -739,21 +748,22 @@ class Array[unchecked out Elem] < Object
   # Returns -1, 0, or 1 as `self` is determined to be less than, equal to, or
   # greater than `other_array`.
   #
-  # Iterates over each index `i` in `(0...self.size)`:
+  # Iterates over each index `i` in <code>(0...self.size)</code>:
   #
-  # *   Computes `result[i]` as `self[i] <=> other_array[i]`.
-  # *   Immediately returns 1 if `result[i]` is 1:
+  # *   Computes <code>result[i]</code> as <code>self[i] <=>
+  #     other_array[i]</code>.
+  # *   Immediately returns 1 if <code>result[i]</code> is 1:
   #
   #         [0, 1, 2] <=> [0, 0, 2] # => 1
   #
-  # *   Immediately returns -1 if `result[i]` is -1:
+  # *   Immediately returns -1 if <code>result[i]</code> is -1:
   #
   #         [0, 1, 2] <=> [0, 2, 2] # => -1
   #
-  # *   Continues if `result[i]` is 0.
+  # *   Continues if <code>result[i]</code> is 0.
   #
-  # When every `result` is 0, returns `self.size <=> other_array.size` (see
-  # Integer#<=>):
+  # When every `result` is 0, returns <code>self.size <=> other_array.size</code>
+  # (see Integer#<=>):
   #
   #     [0, 1, 2] <=> [0, 1]        # => 1
   #     [0, 1, 2] <=> [0, 1, 2]     # => 0
@@ -768,7 +778,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Comparing](rdoc-ref:Array@Methods+for+Comparing).
   #
-  def <=>: (untyped) -> ::Integer?
+  def <=>: (untyped) -> Integer? # Until we can do `where E: RBS::Ops::_Compare`, this is always going to return `Integer?`
 
   # <!--
   #   rdoc-file=array.c
@@ -778,7 +788,7 @@ class Array[unchecked out Elem] < Object
   #
   # *   `self` and `other_array` are the same size.
   # *   Their corresponding elements are the same; that is, for each index `i` in
-  #     `(0...self.size)`, `self[i] == other_array[i]`.
+  #     <code>(0...self.size)</code>, <code>self[i] == other_array[i]</code>.
   #
   # Examples:
   #
@@ -788,7 +798,7 @@ class Array[unchecked out Elem] < Object
   #     [:foo, 'bar', 2] == [:foo, 'bar', 3]   # => false # Different elements.
   #
   # This method is different from method Array#eql?, which compares elements using
-  # `Object#eql?`.
+  # <code>Object#eql?</code>.
   #
   # Related: see [Methods for Comparing](rdoc-ref:Array@Methods+for+Comparing).
   #
@@ -840,50 +850,52 @@ class Array[unchecked out Elem] < Object
   #
   # If `index` is out of range, returns `nil`.
   #
-  # When two Integer arguments `start` and `length` are given, returns a new
-  # `Array` of size `length` containing successive elements beginning at offset
-  # `start`:
+  # 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:
+  # If <code>start + length</code> is greater than <code>self.length</code>,
+  # returns all elements from offset `start` to the end:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0, 4] # => [:foo, "bar", 2]
   #     a[1, 3] # => ["bar", 2]
   #     a[2, 2] # => [2]
   #
-  # If `start == self.size` and `length >= 0`, returns a new empty `Array`.
+  # If <code>start == self.size</code> and <code>length >= 0</code>, returns a new
+  # empty array.
   #
   # If `length` is negative, returns `nil`.
   #
-  # When a single Range argument `range` is given, treats `range.min` as `start`
-  # above and `range.size` as `length` above:
+  # When a single Range argument `range` is given, treats <code>range.min</code>
+  # as `start` above and <code>range.size</code> as `length` above:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0..1] # => [:foo, "bar"]
   #     a[1..2] # => ["bar", 2]
   #
-  # Special case: If `range.start == a.size`, returns a new empty `Array`.
+  # Special case: If <code>range.start == a.size</code>, returns a new empty
+  # array.
   #
-  # If `range.end` is negative, calculates the end index from the end:
+  # If <code>range.end</code> 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:
+  # If <code>range.start</code> 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`.
+  # If <code>range.start</code> is larger than the array size, returns `nil`.
   #
   #     a = [:foo, 'bar', 2]
   #     a[4..1] # => nil
@@ -891,7 +903,7 @@ class Array[unchecked out Elem] < Object
   #     a[4..-1] # => nil
   #
   # When a single Enumerator::ArithmeticSequence argument `aseq` is given, returns
-  # an `Array` of elements corresponding to the indexes produced by the sequence.
+  # an array of elements corresponding to the indexes produced by the sequence.
   #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..).step(2)] # => ["data1", "data2", "data3"]
@@ -914,9 +926,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def []: %a{implicitly-returns-nil} (int index) -> Elem
-        | (int start, int length) -> ::Array[Elem]?
-        | (::Range[::Integer?] range) -> ::Array[Elem]?
+  def []: %a{implicitly-returns-nil} (int index) -> E
+        | (int start, int length) -> Array[E]?
+        | (range[int] range) -> Array[E]?
 
   # <!--
   #   rdoc-file=array.c
@@ -963,7 +975,7 @@ class Array[unchecked out Elem] < Object
   #     a[0] = 'foo' # => "foo"
   #     a # => ["foo", "bar", 2]
   #
-  # If `index` is greater than `self.length`, extends the array:
+  # If `index` is greater than <code>self.length</code>, extends the array:
   #
   #     a = [:foo, 'bar', 2]
   #     a[7] = 'foo' # => "foo"
@@ -976,8 +988,8 @@ class Array[unchecked out Elem] < Object
   #     a # => [:foo, "bar", "two"]
   #
   # 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`:
+  # array, removes <code>length - 1</code> elements beginning at offset `start`,
+  # and assigns `object` at offset `start`:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0, 2] = 'foo' # => "foo"
@@ -989,8 +1001,8 @@ class Array[unchecked out Elem] < Object
   #     a[-2, 2] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
   #
-  # If `start` is non-negative and outside the array (` >= self.size`), extends
-  # the array with `nil`, assigns `object` at offset `start`, and ignores
+  # If `start` is non-negative and outside the array (<code> >= self.size</code>),
+  # extends the array with `nil`, assigns `object` at offset `start`, and ignores
   # `length`:
   #
   #     a = [:foo, 'bar', 2]
@@ -1010,36 +1022,39 @@ class Array[unchecked out Elem] < Object
   #     a[1, 5] = 'foo' # => "foo"
   #     a # => [:foo, "foo"]
   #
-  # When Range argument `range` is given and `object` is not an `Array`, removes
-  # `length - 1` elements beginning at offset `start`, and assigns `object` at
-  # offset `start`:
+  # When Range argument `range` is given and `object` is not an array, removes
+  # <code>length - 1</code> 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:
+  # if <code>range.begin</code> 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`, extends the array with `nil`,
-  # assigns `object` at offset `range.begin`, and ignores `length`:
+  # If the array length is less than <code>range.begin</code>, extends the array
+  # with `nil`, assigns `object` at offset <code>range.begin</code>, 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`:
+  # If <code>range.end</code> 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:
+  # If <code>range.end</code> is negative, assigns `object` at offset `start`,
+  # retains <code>range.end.abs -1</code> elements past that, and removes those
+  # beyond:
   #
   #     a = [:foo, 'bar', 2]
   #     a[1..-1] = 'foo' # => "foo"
@@ -1052,8 +1067,8 @@ class Array[unchecked out Elem] < Object
   #     a # => [:foo, "foo", "bar", 2]
   #     a = [:foo, 'bar', 2]
   #
-  # If `range.end` is too large for the existing array, replaces array elements,
-  # but does not extend the array with `nil` values:
+  # If <code>range.end</code> 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"
@@ -1061,13 +1076,11 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def []=: (int index, Elem obj) -> Elem
-         | (int start, int length, Elem obj) -> Elem
-         | (int start, int length, ::Array[Elem]) -> ::Array[Elem]
-         | (int start, int length, nil) -> nil
-         | (::Range[::Integer?], Elem obj) -> Elem
-         | (::Range[::Integer?], ::Array[Elem]) -> ::Array[Elem]
-         | (::Range[::Integer?], nil) -> nil
+  def []=: (int index, E object) -> E
+         | [T < _ToAry[E]] (range[int?] range, T array) -> T
+         | (range[int?] range, E object) -> E
+         | [T < _ToAry[E]] (int start, int length, T array) -> T
+         | (int start, int length, E object) -> E
 
   # <!--
   #   rdoc-file=array.c
@@ -1084,8 +1097,8 @@ class Array[unchecked out Elem] < Object
   #     [[], {}, '', 0, 0.0, nil].all?        # => false # nil is not truthy.
   #     [[], {}, '', 0, 0.0, false].all?      # => false # false is not truthy.
   #
-  # With argument `object` given, returns whether `object === ele` for every
-  # element `ele` in `self`:
+  # With argument `object` given, returns whether <code>object === ele</code> for
+  # every element `ele` in `self`:
   #
   #     [0, 0, 0].all?(0)                    # => true
   #     [0, 1, 2].all?(1)                    # => false
@@ -1107,8 +1120,8 @@ class Array[unchecked out Elem] < Object
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
   def all?: () -> bool
-          | (_Pattern[Elem] pattern) -> bool
-          | () { (Elem obj) -> boolish } -> bool
+          | (RBS::Ops::_CaseEqual[E, boolish] pattern) -> bool
+          | () { (E element) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=array.c
@@ -1126,8 +1139,8 @@ class Array[unchecked out Elem] < Object
   #     [nil, false, ''].any? # => true  # String object is truthy.
   #     [nil, false].any?     # => false # Nil and false are not truthy.
   #
-  # With argument `object` given, returns whether `object === ele` for any element
-  # `ele` in `self`:
+  # With argument `object` given, returns whether <code>object === ele</code> for
+  # any element `ele` in `self`:
   #
   #     [nil, false, 0].any?(0)          # => true
   #     [nil, false, 1].any?(0)          # => false
@@ -1148,7 +1161,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  alias any? all?
+  def any?: () -> bool
+          | (RBS::Ops::_CaseEqual[E, boolish] pattern) -> bool
+          | () { (E element) -> boolish } -> bool
 
   # <!-- rdoc-file=array.c -->
   # Appends each argument in `objects` to `self`; returns `self`:
@@ -1170,7 +1185,7 @@ class Array[unchecked out Elem] < Object
   #   - assoc(object) -> found_array or nil
   # -->
   # Returns the first element `ele` in `self` such that `ele` is an array and
-  # `ele[0] == object`:
+  # <code>ele[0] == object</code>:
   #
   #     a = [{foo: 0}, [2, 4], [4, 5, 6], [4, 5]]
   #     a.assoc(4) # => [4, 5, 6]
@@ -1180,7 +1195,7 @@ class Array[unchecked out Elem] < Object
   # Related: Array#rassoc; see also [Methods for
   # Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def assoc: (untyped) -> ::Array[untyped]?
+  def assoc: (untyped object) -> Array[untyped]? # where E: _ToAry[X], object: _Equal
 
   # <!--
   #   rdoc-file=array.c
@@ -1204,7 +1219,7 @@ class Array[unchecked out Elem] < Object
   # Related: Array#[]; see also [Methods for
   # Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def at: %a{implicitly-returns-nil} (int index) -> Elem
+  def at: %a{implicitly-returns-nil} (int index) -> E
 
   # <!--
   #   rdoc-file=array.c
@@ -1214,13 +1229,13 @@ class Array[unchecked out Elem] < Object
   # Returns the element from `self` found by a binary search, or `nil` if the
   # search found no suitable element.
   #
-  # See [Binary Searching](rdoc-ref:bsearch.rdoc).
+  # See [Binary Searching](rdoc-ref:language/bsearch.rdoc).
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def bsearch: () -> ::Enumerator[Elem, Elem?]
-             | () { (Elem) -> (true | false) } -> Elem?
-             | () { (Elem) -> ::Integer } -> Elem?
+  def bsearch: () { (E element) -> bool? } -> E?
+             | () { (E element) -> Numeric? } -> E?
+             | () -> Enumerator[E, E?]
 
   # <!--
   #   rdoc-file=array.c
@@ -1230,12 +1245,13 @@ class Array[unchecked out Elem] < Object
   # Returns the integer index of the element from `self` found by a binary search,
   # or `nil` if the search found no suitable element.
   #
-  # See [Binary Searching](rdoc-ref:bsearch.rdoc).
+  # See [Binary Searching](rdoc-ref:language/bsearch.rdoc).
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def bsearch_index: () { (Elem) -> (true | false) } -> ::Integer?
-                   | () { (Elem) -> ::Integer } -> ::Integer?
+  def bsearch_index: () { (E element) -> bool? } -> Integer?
+                   | () { (E element) -> Numeric? } -> Integer?
+                   | () -> Enumerator[E, Integer?]
 
   # <!--
   #   rdoc-file=array.c
@@ -1269,14 +1285,14 @@ class Array[unchecked out Elem] < Object
   # Related: #collect!; see also [Methods for
   # Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  def collect: [U] () { (Elem item) -> U } -> ::Array[U]
-             | () -> ::Enumerator[Elem, ::Array[untyped]]
+  def collect: [T] () { (E item) -> T } -> Array[T]
+             | () -> Enumerator[E, Array[untyped]]
 
   # <!--
   #   rdoc-file=array.c
-  #   - collect! {|element| ... } -> new_array
+  #   - collect! {|element| ... } -> self
   #   - collect! -> new_enumerator
-  #   - map! {|element| ... } -> new_array
+  #   - map! {|element| ... } -> self
   #   - map! -> new_enumerator
   # -->
   # With a block given, calls the block with each element of `self` and replaces
@@ -1290,8 +1306,8 @@ class Array[unchecked out Elem] < Object
   # Related: #collect; see also [Methods for
   # Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  def collect!: () { (Elem item) -> Elem } -> self
-              | () -> ::Enumerator[Elem, self]
+  def collect!: () { (E element) -> E } -> self
+              | () -> Enumerator[E, self]
 
   # <!--
   #   rdoc-file=array.c
@@ -1300,8 +1316,8 @@ class Array[unchecked out Elem] < Object
   # -->
   # When a block and a positive [integer-convertible
   # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects)
-  # argument `count` (`0 < count <= self.size`) are given, calls the block with
-  # each combination of `self` of size `count`; returns `self`:
+  # argument `count` (<code>0 < count <= self.size</code>) are given, calls the
+  # block with each combination of `self` of size `count`; returns `self`:
   #
   #     a = %w[a b c]                                   # => ["a", "b", "c"]
   #     a.combination(2) {|combination| p combination } # => ["a", "b", "c"]
@@ -1324,8 +1340,8 @@ class Array[unchecked out Elem] < Object
   #     []
   #     []
   #
-  # When `count` is negative or larger than `self.size` and `self` is non-empty,
-  # does not call the block:
+  # When `count` is negative or larger than <code>self.size</code> and `self` is
+  # non-empty, does not call the block:
   #
   #     a.combination(-1) {|combination| fail 'Cannot happen' } # => ["a", "b", "c"]
   #     a.combination(4)  {|combination| fail 'Cannot happen' } # => ["a", "b", "c"]
@@ -1335,8 +1351,8 @@ class Array[unchecked out Elem] < Object
   # Related: Array#permutation; see also [Methods for
   # Iterating](rdoc-ref:Array@Methods+for+Iterating).
   #
-  def combination: (int n) { (::Array[Elem]) -> void } -> self
-                 | (int n) -> ::Enumerator[::Array[Elem], self]
+  def combination: (int count) { (Array[E] combination) -> void } -> self
+                 | (int count) -> Enumerator[Array[E], self]
 
   # <!--
   #   rdoc-file=array.c
@@ -1351,7 +1367,7 @@ class Array[unchecked out Elem] < Object
   # Related: Array#compact!; see also [Methods for
   # Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def compact: () -> ::Array[Elem]
+  def compact: () -> Array[E] # it'd be nice if there was a way to do `Array[E - nil]`
 
   # <!--
   #   rdoc-file=array.c
@@ -1382,7 +1398,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def concat: (*::Array[Elem] arrays) -> self
+  def concat: (*array[E] other_arrays) -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -1396,7 +1412,8 @@ class Array[unchecked out Elem] < Object
   #
   #     [0, :one, 'two', 3, 3.0].count # => 5
   #
-  # With argument `object` given, returns the count of elements `==` to `object`:
+  # With argument `object` given, returns the count of elements <code>==</code> to
+  # `object`:
   #
   #     [0, :one, 'two', 3, 3.0].count(3) # => 2
   #
@@ -1406,13 +1423,12 @@ class Array[unchecked out Elem] < Object
   #     [0, 1, 2, 3].count {|element| element > 1 } # => 2
   #
   # With argument `object` and a block given, issues a warning, ignores the block,
-  # and returns the count of elements `==` to `object`.
+  # and returns the count of elements <code>==</code> to `object`.
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def count: () -> ::Integer
-           | (Elem obj) -> ::Integer
-           | () { (Elem) -> boolish } -> ::Integer
+  def count: () ?{ (E element) -> boolish } -> Integer
+           | (untyped object) -> Integer # where E: RBS::Ops::_Equal
 
   # <!--
   #   rdoc-file=array.c
@@ -1446,8 +1462,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Iterating](rdoc-ref:Array@Methods+for+Iterating).
   #
-  def cycle: (?int? n) { (Elem) -> void } -> nil
-           | (?int? n) -> ::Enumerator[Elem, nil]
+  def cycle: (?int? n) { (E element) -> void } -> nil
+           | (?int? n) -> Enumerator[E, nil]
 
   # <!--
   #   rdoc-file=array.c
@@ -1463,8 +1479,8 @@ class Array[unchecked out Elem] < Object
   # -->
   # Removes zero or more elements from `self`.
   #
-  # With no block given, removes from `self` each element `ele` such that `ele ==
-  # object`; returns the last removed element:
+  # With no block given, removes from `self` each element `ele` such that
+  # <code>ele == object</code>; returns the last removed element:
   #
   #     a = [0, 1, 2, 2.0]
   #     a.delete(2) # => 2.0
@@ -1474,8 +1490,8 @@ class Array[unchecked out Elem] < Object
   #
   #     a.delete(2) # => nil
   #
-  # With a block given, removes from `self` each element `ele` such that `ele ==
-  # object`.
+  # With a block given, removes from `self` each element `ele` such that <code>ele
+  # == object</code>.
   #
   # If any such elements are found, ignores the block and returns the last removed
   # element:
@@ -1491,8 +1507,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def delete: (Elem obj) -> Elem?
-            | [S, T] (S obj) { (S) -> T } -> (Elem | T)
+  def delete: (untyped object) -> E? # where E: _Comparable
+            | [S, T] (S object) { (S object) -> T } -> (E | T)
 
   # <!--
   #   rdoc-file=array.c
@@ -1522,7 +1538,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def delete_at: %a{implicitly-returns-nil} (int index) -> Elem
+  def delete_at: %a{implicitly-returns-nil} (int index) -> E
 
   # <!--
   #   rdoc-file=array.c
@@ -1539,16 +1555,33 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def delete_if: () { (Elem item) -> boolish } -> self
-               | () -> ::Enumerator[Elem, self]
+  def delete_if: () { (E item) -> boolish } -> self
+               | () -> Enumerator[E, self]
+
+  # <!-- rdoc-file=array.c -->
+  # Returns the first element for which the block returns a truthy value.
+  #
+  # With a block given, calls the block with successive elements of the array;
+  # returns the first element for which the block returns a truthy value:
+  #
+  #     [1, 3, 5].find {|element| element > 2}                # => 3
+  #
+  # If no such element is found, calls `if_none_proc` and returns its return
+  # value.
+  #
+  #     [1, 3, 5].find(proc {-1}) {|element| element > 12} # => -1
+  #
+  # With no block given, returns an Enumerator.
+  #
+  alias detect find
 
   # <!--
   #   rdoc-file=array.c
   #   - difference(*other_arrays = []) -> new_array
   # -->
   # Returns a new array containing only those elements from `self` that are not
-  # found in any of the given `other_arrays`; items are compared using `eql?`;
-  # order from `self` is preserved:
+  # found in any of the given `other_arrays`; items are compared using
+  # <code>eql?</code>;  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]
@@ -1560,11 +1593,11 @@ class Array[unchecked out Elem] < Object
   # Related: Array#-; see also [Methods for
   # Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def difference: (*::Array[untyped] arrays) -> ::Array[Elem]
+  def difference: (*array[untyped] other_arrays) -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.dig(index, *identifiers) -> object
+  #   - dig(index, *identifiers) -> object
   # -->
   # Finds and returns the object in nested object specified by `index` and
   # `identifiers`; the nested objects may be instances of various classes. See
@@ -1580,8 +1613,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def dig: (int idx) -> Elem?
-         | (int idx, untyped, *untyped) -> untyped
+  def dig: (int index) -> E?
+         | (int index, untyped, *untyped) -> untyped
 
   # <!--
   #   rdoc-file=array.c
@@ -1600,7 +1633,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def drop: (int n) -> ::Array[Elem]
+  def drop: (int count) -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -1619,8 +1652,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def drop_while: () { (Elem obj) -> boolish } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def drop_while: () { (E element) -> boolish } -> Array[E]
+                | () -> Enumerator[E, Array[E]]
 
   # <!--
   #   rdoc-file=array.c
@@ -1653,8 +1686,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Iterating](rdoc-ref:Array@Methods+for+Iterating).
   #
-  def each: () -> ::Enumerator[Elem, self]
-          | () { (Elem item) -> void } -> self
+  def each: () { (E element) -> void } -> self
+          | () -> Enumerator[E, self]
 
   # <!--
   #   rdoc-file=array.c
@@ -1688,12 +1721,12 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Iterating](rdoc-ref:Array@Methods+for+Iterating).
   #
-  def each_index: () { (::Integer index) -> void } -> self
-                | () -> ::Enumerator[::Integer, self]
+  def each_index: () { (Integer index) -> void } -> self
+                | () -> Enumerator[Integer, self]
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.empty?  -> true or false
+  #   - empty?  -> true or false
   # -->
   # Returns `true` if the count of elements in `self` is zero, `false` otherwise.
   #
@@ -1706,7 +1739,7 @@ class Array[unchecked out Elem] < Object
   #   - eql?(other_array) -> true or false
   # -->
   # 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])`:
+  # index `i` in `self`, <code>self[i].eql?(other_array[i])</code>:
   #
   #     a0 = [:foo, 'bar', 2]
   #     a1 = [:foo, 'bar', 2]
@@ -1715,7 +1748,7 @@ class Array[unchecked out Elem] < Object
   # Otherwise, returns `false`.
   #
   # This method is different from method Array#==, which compares using method
-  # `Object#==`.
+  # <code>Object#==</code>.
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
@@ -1761,9 +1794,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def fetch: (int index) -> Elem
-           | [T] (int index, T default) -> (Elem | T)
-           | [T] (int index) { (int index) -> T } -> (Elem | T)
+  def fetch: (int index) -> E
+           | [T] (int index, T default) -> (E | T)
+           | [I < _ToInt, T] (I index) { (I index) -> T } -> (E | T)
 
   # <!--
   #   rdoc-file=array.rb
@@ -1800,14 +1833,15 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def fetch_values: (*int indexes) -> self
+  def fetch_values: (*int indexes) -> Array[E]
+                  | [I < _ToInt, T] (*I indexes) { (I index) -> T } -> Array[E | T]
 
   # <!--
   #   rdoc-file=array.c
-  #   - fill(object, start = nil, count = nil) -> new_array
-  #   - fill(object, range) -> new_array
-  #   - fill(start = nil, count = nil) {|element| ... } -> new_array
-  #   - fill(range) {|element| ... } -> new_array
+  #   - fill(object, start = nil, count = nil) -> self
+  #   - fill(object, range) -> self
+  #   - fill(start = nil, count = nil) {|element| ... } -> self
+  #   - fill(range) {|element| ... } -> self
   # -->
   # Replaces selected elements in `self`; may add elements to `self`; always
   # returns `self` (never a new array).
@@ -1980,11 +2014,10 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def fill: (Elem obj) -> self
-          | (Elem obj, int? start, ?int? length) -> self
-          | (Elem obj, ::Range[::Integer] range) -> self
-          | (?int? start, ?int? length) { (::Integer index) -> Elem } -> self
-          | (::Range[::Integer] range) { (::Integer index) -> Elem } -> self
+  def fill: (E object, ?int? start, ?int? length) -> self
+          | (E object, range[int?] range) -> self
+          | (?int? start, ?int? length) { (Integer index) -> E } -> self
+          | (range[int?] range) { (Integer index) -> E } -> self
 
   # <!-- rdoc-file=array.c -->
   # With a block given, calls the block with each element of `self`; returns a new
@@ -1999,8 +2032,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def filter: () { (Elem item) -> boolish } -> ::Array[Elem]
-            | () -> ::Enumerator[Elem, ::Array[Elem]]
+  alias filter select
 
   # <!-- rdoc-file=array.c -->
   # With a block given, calls the block with each element of `self`; removes from
@@ -2017,8 +2049,31 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def filter!: () { (Elem item) -> boolish } -> self?
-             | () -> ::Enumerator[Elem, self?]
+  alias filter! select!
+
+  # <!--
+  #   rdoc-file=array.c
+  #   - find(if_none_proc = nil) {|element| ... } -> object or nil
+  #   - find(if_none_proc = nil) -> enumerator
+  # -->
+  # Returns the first element for which the block returns a truthy value.
+  #
+  # With a block given, calls the block with successive elements of the array;
+  # returns the first element for which the block returns a truthy value:
+  #
+  #     [1, 3, 5].find {|element| element > 2}                # => 3
+  #
+  # If no such element is found, calls `if_none_proc` and returns its return
+  # value.
+  #
+  #     [1, 3, 5].find(proc {-1}) {|element| element > 12} # => -1
+  #
+  # With no block given, returns an Enumerator.
+  #
+  def find: () { (E) -> boolish } -> E?
+          | () -> Enumerator[E, E?]
+          | [T] (Enumerable::_NotFound[T]? ifnone) { (E) -> boolish } -> (E | T)
+          | [T] (Enumerable::_NotFound[T]? ifnone) -> Enumerator[E, E | T]
 
   # <!--
   #   rdoc-file=array.c
@@ -2032,7 +2087,7 @@ class Array[unchecked out Elem] < Object
   # Returns the zero-based integer index of a specified element, or `nil`.
   #
   # With only argument `object` given, returns the index of the first element
-  # `element` for which `object == element`:
+  # `element` for which <code>object == element</code>:
   #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.index('bar') # => 1
@@ -2051,9 +2106,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def find_index: (untyped obj) -> ::Integer?
-                | () { (Elem item) -> boolish } -> ::Integer?
-                | () -> ::Enumerator[Elem, ::Integer?]
+  def find_index: (untyped object) -> Integer? # where E: RBS::Ops::_Equal
+                | () { (E element) -> boolish } -> Integer?
+                | () -> Enumerator[E, Integer?]
 
   # <!--
   #   rdoc-file=array.rb
@@ -2081,8 +2136,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def first: %a{implicitly-returns-nil} () -> Elem
-           | (int n) -> ::Array[Elem]
+  def first: %a{implicitly-returns-nil} () -> E
+           | (int count) -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -2117,7 +2172,7 @@ class Array[unchecked out Elem] < Object
   # Related: Array#flatten!; see also [Methods for
   # Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  def flatten: (?int level) -> ::Array[untyped]
+  def flatten: (?int? level) -> Array[untyped]
 
   # <!--
   #   rdoc-file=array.c
@@ -2153,7 +2208,25 @@ class Array[unchecked out Elem] < Object
   # Related: Array#flatten; see also [Methods for
   # Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def flatten!: (?int level) -> self?
+  def flatten!: (?int? level) -> self?
+
+  # <!--
+  #   rdoc-file=array.c
+  #   - freeze -> self
+  # -->
+  # Freezes `self` (if not already frozen); returns `self`:
+  #
+  #     a = []
+  #     a.frozen? # => false
+  #     a.freeze
+  #     a.frozen? # => true
+  #
+  # No further changes may be made to `self`; raises FrozenError if a change is
+  # attempted.
+  #
+  # Related: Kernel#frozen?.
+  #
+  def freeze: () -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -2168,13 +2241,14 @@ class Array[unchecked out Elem] < Object
   #     ['a', 'b'].hash == ['a', 'c'].hash # => false
   #     ['a', 'b'].hash == ['a'].hash      # => false
   #
-  def hash: () -> ::Integer
+  def hash: () -> Integer # where E: _Hash
 
   # <!--
   #   rdoc-file=array.c
   #   - include?(object) -> true or false
   # -->
-  # Returns whether for some element `element` in `self`, `object == element`:
+  # Returns whether for some element `element` in `self`, <code>object ==
+  # element</code>:
   #
   #     [0, 1, 2].include?(2)   # => true
   #     [0, 1, 2].include?(2.0) # => true
@@ -2182,13 +2256,13 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def include?: (Elem object) -> bool
+  def include?: (untyped object) -> bool # where E: RBS::Ops::_Equals
 
   # <!-- rdoc-file=array.c -->
   # Returns the zero-based integer index of a specified element, or `nil`.
   #
   # With only argument `object` given, returns the index of the first element
-  # `element` for which `object == element`:
+  # `element` for which <code>object == element</code>:
   #
   #     a = [:foo, 'bar', 2, 'bar']
   #     a.index('bar') # => 1
@@ -2221,13 +2295,14 @@ class Array[unchecked out Elem] < Object
   #     a = ['a', 'b', 'c']     # => ["a", "b", "c"]
   #     a.insert(1, :x, :y, :z) # => ["a", :x, :y, :z, "b", "c"]
   #
-  # Extends the array if `index` is beyond the array (`index >= self.size`):
+  # Extends the array if `index` is beyond the array (<code>index >=
+  # self.size</code>):
   #
   #     a = ['a', 'b', 'c']     # => ["a", "b", "c"]
   #     a.insert(5, :x, :y, :z) # => ["a", "b", "c", nil, nil, :x, :y, :z]
   #
   # When `index` is negative, inserts `objects` *after* the element at offset
-  # `index + self.size`:
+  # <code>index + self.size</code>:
   #
   #     a = ['a', 'b', 'c']      # => ["a", "b", "c"]
   #     a.insert(-2, :x, :y, :z) # => ["a", "b", :x, :y, :z, "c"]
@@ -2244,49 +2319,50 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def insert: (int index, *Elem obj) -> self
+  def insert: (int index, *E objects) -> self
 
   # <!--
   #   rdoc-file=array.c
   #   - inspect -> new_string
   #   - to_s -> new_string
   # -->
-  # Returns the new string formed by calling method `#inspect` on each array
-  # element:
+  # Returns the new string formed by calling method <code>#inspect</code> on each
+  # array element:
   #
   #     a = [:foo, 'bar', 2]
   #     a.inspect # => "[:foo, \"bar\", 2]"
   #
   # Related: see [Methods for Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  def inspect: () -> String
+  def inspect: () -> String # where E: _Inspect
 
   # <!--
   #   rdoc-file=array.c
   #   - intersect?(other_array) -> true or false
   # -->
-  # Returns whether `other_array` has at least one element that is `#eql?` to some
-  # element of `self`:
+  # Returns whether `other_array` has at least one element that is
+  # <code>#eql?</code> to some element of `self`:
   #
   #     [1, 2, 3].intersect?([3, 4, 5]) # => true
   #     [1, 2, 3].intersect?([4, 5, 6]) # => false
   #
-  # Each element must correctly implement method `#hash`.
+  # Each element must correctly implement method <code>#hash</code>.
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def intersect?: (_ToAry[untyped]) -> bool
+  def intersect?: (array[untyped] other_array) -> bool # where E: _Eql?
 
   # <!--
   #   rdoc-file=array.c
   #   - intersection(*other_arrays) -> new_array
   # -->
-  # Returns a new array containing each element in `self` that is `#eql?` to at
-  # least one element in each of the given `other_arrays`; duplicates are omitted:
+  # Returns a new array containing each element in `self` that is
+  # <code>#eql?</code> to at least one element in each of the given
+  # `other_arrays`; duplicates are omitted:
   #
   #     [0, 0, 1, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3]) # => [0, 1]
   #
-  # Each element must correctly implement method `#hash`.
+  # Each element must correctly implement method <code>#hash</code>.
   #
   # Order from `self` is preserved:
   #
@@ -2296,20 +2372,21 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def intersection: (*::Array[untyped] | _ToAry[untyped] other_ary) -> ::Array[Elem]
+  def intersection: (*array[untyped] other_arrays) -> Array[E] # where E: _Eql?
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.join(separator = $,) -> new_string
+  #   - join(separator = $,) -> new_string
   # -->
   # Returns the new string formed by joining the converted elements of `self`; for
   # each element `element`:
   #
-  # *   Converts recursively using `element.join(separator)` if `element` is a
-  #     `kind_of?(Array)`.
-  # *   Otherwise, converts using `element.to_s`.
+  # *   Converts recursively using <code>element.join(separator)</code> if
+  #     `element` is a <code>kind_of?(Array)</code>.
+  # *   Otherwise, converts using <code>element.to_s</code>.
   #
-  # With no argument given, joins using the output field separator, `$,`:
+  # With no argument given, joins using the output field separator,
+  # <code>$,</code>:
   #
   #     a = [:foo, 'bar', 2]
   #     $, # => nil
@@ -2327,7 +2404,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  def join: (?string separator) -> String
+  def join: (?string? separator) -> String # where E: _ToS
 
   # <!--
   #   rdoc-file=array.c
@@ -2344,8 +2421,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def keep_if: () { (Elem item) -> boolish } -> self
-             | () -> ::Enumerator[Elem, self]
+  def keep_if: () { (E element) -> boolish } -> self
+             | () -> Enumerator[E, self]
 
   # <!--
   #   rdoc-file=array.rb
@@ -2372,8 +2449,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def last: %a{implicitly-returns-nil} () -> Elem
-          | (int n) -> ::Array[Elem]
+  def last: %a{implicitly-returns-nil} () -> E
+          | (int count) -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -2387,7 +2464,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def length: () -> ::Integer
+  def length: () -> Integer
 
   # <!-- rdoc-file=array.c -->
   # With a block given, calls the block with each element of `self`; returns a new
@@ -2432,16 +2509,17 @@ class Array[unchecked out Elem] < Object
   #
   # Does not modify `self`.
   #
-  # With no block given, each element in `self` must respond to method `#<=>` with
-  # a numeric.
+  # With no block given, each element in `self` must respond to method
+  # <code>#<=></code> with a numeric.
   #
   # With no argument and no block, returns the element in `self` having the
-  # maximum value per method `#<=>`:
+  # maximum value per method <code>#<=></code>:
   #
   #     [1, 0, 3, 2].max # => 3
   #
   # With non-negative numeric argument `count` and no block, returns a new array
-  # with at most `count` elements, in descending order, per method `#<=>`:
+  # with at most `count` elements, in descending order, per method
+  # <code>#<=></code>:
   #
   #     [1, 0, 3, 2].max(3)   # => [3, 2, 1]
   #     [1, 0, 3, 2].max(3.0) # => [3, 2, 1]
@@ -2450,8 +2528,9 @@ class Array[unchecked out Elem] < Object
   #
   # With a block given, the block must return a numeric.
   #
-  # 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:
+  # With a block and no argument, calls the block <code>self.size - 1</code> times
+  # to compare elements; returns the element having the maximum value per the
+  # block:
   #
   #     ['0', '', '000', '00'].max {|a, b| a.size <=> b.size }
   #     # => "000"
@@ -2464,10 +2543,12 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def max: %a{implicitly-returns-nil} () -> Elem
-         | %a{implicitly-returns-nil} () { (Elem a, Elem b) -> ::Integer? } -> Elem
-         | (int n) -> ::Array[Elem]
-         | (int n) { (Elem a, Elem b) -> ::Integer? } -> ::Array[Elem]
+  def max: %a{implicitly-returns-nil} () -> E # where E: Comparable::_WithSpaceshipOperator
+         | %a{implicitly-returns-nil} () { (E a, E b) -> Comparable::_CompareToZero } -> E
+         | %a{implicitly-returns-nil} %a{warning: returning `nil` will always raise at runtime} () { (E a, E b) -> Comparable::_CompareToZero? } -> E
+         | (int count) -> Array[E] # where E: Comparable::_WithSpaceshipOperator
+         | (int count) { (E a, E b) -> Comparable::_CompareToZero } -> Array[E]
+         | %a{warning: returning `nil` will always raise at runtime} (int count) { (E a, E b) -> Comparable::_CompareToZero? } -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -2483,16 +2564,17 @@ class Array[unchecked out Elem] < Object
   #
   # Does not modify `self`.
   #
-  # With no block given, each element in `self` must respond to method `#<=>` with
-  # a numeric.
+  # With no block given, each element in `self` must respond to method
+  # <code>#<=></code> with a numeric.
   #
   # With no argument and no block, returns the element in `self` having the
-  # minimum value per method `#<=>`:
+  # minimum value per method <code>#<=></code>:
   #
   #     [1, 0, 3, 2].min # => 0
   #
   # With non-negative numeric argument `count` and no block, returns a new array
-  # with at most `count` elements, in ascending order, per method `#<=>`:
+  # with at most `count` elements, in ascending order, per method
+  # <code>#<=></code>:
   #
   #     [1, 0, 3, 2].min(3)   # => [0, 1, 2]
   #     [1, 0, 3, 2].min(3.0) # => [0, 1, 2]
@@ -2501,8 +2583,9 @@ class Array[unchecked out Elem] < Object
   #
   # With a block given, the block must return a numeric.
   #
-  # 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:
+  # With a block and no argument, calls the block <code>self.size - 1</code> times
+  # to compare elements; returns the element having the minimum value per the
+  # block:
   #
   #     ['0', '', '000', '00'].min {|a, b| a.size <=> b.size }
   #     # => ""
@@ -2515,7 +2598,12 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  alias min max
+  def min: %a{implicitly-returns-nil} () -> E # where E: Comparable::_WithSpaceshipOperator
+         | %a{implicitly-returns-nil} () { (E a, E b) -> Comparable::_CompareToZero } -> E
+         | %a{implicitly-returns-nil} %a{warning: returning `nil` will always raise at runtime} () { (E a, E b) -> Comparable::_CompareToZero? } -> E
+         | (int count) -> Array[E] # where E: Comparable::_WithSpaceshipOperator
+         | (int count) { (E a, E b) -> Comparable::_CompareToZero } -> Array[E]
+         | %a{warning: returning `nil` will always raise at runtime} (int count) { (E a, E b) -> Comparable::_CompareToZero? } -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -2526,21 +2614,22 @@ class Array[unchecked out Elem] < Object
   # elements from `self`; does not modify `self`.
   #
   # With no block given, the minimum and maximum values are determined using
-  # method `#<=>`:
+  # method <code>#<=></code>:
   #
   #     [1, 0, 3, 2].minmax # => [0, 3]
   #
   # With a block given, the block must return a numeric; the block is called
-  # `self.size - 1` times to compare elements; returns the elements having the
-  # minimum and maximum values per the block:
+  # <code>self.size - 1</code> times to compare elements; returns the elements
+  # having the minimum and maximum values per the block:
   #
   #     ['0', '', '000', '00'].minmax {|a, b| a.size <=> b.size }
   #     # => ["", "000"]
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def minmax: () -> [ Elem?, Elem? ]
-            | () { (Elem a, Elem b) -> ::Integer? } -> [ Elem?, Elem? ]
+  def minmax: () -> [ E?, E? ] # where E: Comparable::_WithSpaceshipOperator
+            | () { (E a, E b) -> Comparable::_CompareToZero } -> [ E?, E? ]
+            | %a{warning: returning `nil` will always raise at runtime} () { (E a, E b) -> Comparable::_CompareToZero? } -> [ E?, E? ]
 
   # <!--
   #   rdoc-file=array.c
@@ -2559,7 +2648,7 @@ class Array[unchecked out Elem] < Object
   #     [].none?              # => true
   #
   # With argument `object` given, returns `false` if for any element `element`,
-  # `object === element`; `true` otherwise:
+  # <code>object === element</code>; `true` otherwise:
   #
   #     ['food', 'drink'].none?(/bar/) # => true
   #     ['food', 'drink'].none?(/foo/) # => false
@@ -2575,7 +2664,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  alias none? all?
+  def none?: () -> bool
+           | (RBS::Ops::_CaseEqual[E, boolish] pattern) -> bool
+           | () { (E element) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=array.c
@@ -2601,7 +2692,7 @@ class Array[unchecked out Elem] < Object
   #     [0, 1, 2].one? {|element| element > 2 } # => false
   #
   # With argument `object` given, returns `true` if for exactly one element
-  # `element`, `object === element`; `false` otherwise:
+  # `element`, <code>object === element</code>; `false` otherwise:
   #
   #     [0, 1, 2].one?(0) # => true
   #     [0, 0, 1].one?(0) # => false
@@ -2612,14 +2703,16 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  alias one? none?
+  def one?: () -> bool
+          | (RBS::Ops::_CaseEqual[E, boolish] pattern) -> bool
+          | () { (E element) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=pack.rb
   #   - 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).
+  # [Packed Data](rdoc-ref:language/packed_data.rdoc).
   #
   def pack: (string fmt, ?buffer: String?) -> String
 
@@ -2631,9 +2724,9 @@ class Array[unchecked out Elem] < Object
   # Iterates over permutations of the elements of `self`; the order of
   # permutations is indeterminate.
   #
-  # With a block and an in-range positive integer argument `count` (`0 < count <=
-  # self.size`) given, calls the block with each permutation of `self` of size
-  # `count`; returns `self`:
+  # With a block and an in-range positive integer argument `count` (<code>0 <
+  # count <= self.size</code>) given, calls the block with each permutation of
+  # `self` of size `count`; returns `self`:
   #
   #     a = [0, 1, 2]
   #     perms = []
@@ -2654,8 +2747,8 @@ class Array[unchecked out Elem] < Object
   #     a.permutation(0) {|perm| perms.push(perm) }
   #     perms # => [[]]
   #
-  # When `count` is out of range (negative or larger than `self.size`), does not
-  # call the block:
+  # When `count` is out of range (negative or larger than <code>self.size</code>),
+  # does not call the block:
   #
   #     a.permutation(-1) {|permutation| fail 'Cannot happen' }
   #     a.permutation(4) {|permutation| fail 'Cannot happen' }
@@ -2664,8 +2757,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: [Methods for Iterating](rdoc-ref:Array@Methods+for+Iterating).
   #
-  def permutation: (?int n) -> ::Enumerator[::Array[Elem], ::Array[Elem]]
-                 | (?int n) { (::Array[Elem] p) -> void } -> ::Array[Elem]
+  def permutation: (?int? count) { (Array[E] permutation) -> void } -> self
+                 | (?int? count) -> Enumerator[Array[E], self]
 
   # <!--
   #   rdoc-file=array.c
@@ -2696,8 +2789,8 @@ class Array[unchecked out Elem] < Object
   # Related: Array#push; see also [Methods for
   # Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def pop: () -> Elem?
-         | (int n) -> ::Array[Elem]
+  def pop: () -> E?
+         | (int count) -> Array[E]
 
   # <!-- rdoc-file=array.c -->
   # Prepends the given `objects` to `self`:
@@ -2763,10 +2856,14 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def product: () -> ::Array[[ Elem ]]
-             | [X] (::Array[X] other_ary) -> ::Array[[ Elem, X ]]
-             | [X, Y] (::Array[X] other_ary1, ::Array[Y] other_ary2) -> ::Array[[ Elem, X, Y ]]
-             | [U] (*::Array[U] other_arys) -> ::Array[::Array[Elem | U]]
+  def product: () -> Array[[ E ]]
+             | () { ([E] combination) -> void } -> self
+             | [X] (array[X] other_ary) -> Array[[ E, X ]]
+             | [X] (array[X] other_ary) { ([E, X] combination) -> void } -> self
+             | [X, Y] (array[X] other_ary1, array[Y] other_ary2) -> Array[[ E, X, Y ]]
+             | [X, Y] (array[X] other_ary1, array[Y] other_ary2) { ([E, X, Y] combination) -> void } -> self
+             | [U] (*array[U] other_arys) -> Array[Array[E | U]]
+             | [U] (*array[U] other_arys) { (Array[E | U] combination) -> void } -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -2785,14 +2882,14 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def push: (*Elem obj) -> self
+  def push: (*E objects) -> self
 
   # <!--
   #   rdoc-file=array.c
   #   - rassoc(object) -> found_array or nil
   # -->
   # Returns the first element `ele` in `self` such that `ele` is an array and
-  # `ele[1] == object`:
+  # <code>ele[1] == object</code>:
   #
   #     a = [{foo: 0}, [2, 4], [4, 5, 6], [4, 5]]
   #     a.rassoc(4) # => [2, 4]
@@ -2803,7 +2900,7 @@ class Array[unchecked out Elem] < Object
   # Related: Array#assoc; see also [Methods for
   # Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  alias rassoc assoc
+  def rassoc: (untyped object) -> Array[untyped]? # where E: _ToAry, object: _Equal
 
   # <!--
   #   rdoc-file=array.c
@@ -2842,8 +2939,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def reject!: () { (Elem item) -> boolish } -> self?
-             | () -> ::Enumerator[Elem, self?]
+  def reject!: () { (E item) -> boolish } -> self?
+             | () -> Enumerator[E, self?]
 
   # <!--
   #   rdoc-file=array.c
@@ -2856,7 +2953,7 @@ class Array[unchecked out Elem] < Object
   #
   # If a positive integer argument `size` is given, calls the block with each
   # `size`-tuple repeated combination of the elements of `self`. The number of
-  # combinations is `(size+1)(size+2)/2`.
+  # combinations is <code>(size+1)(size+2)/2</code>.
   #
   # Examples:
   #
@@ -2882,8 +2979,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def repeated_combination: (int n) { (::Array[Elem] c) -> void } -> self
-                          | (int n) -> ::Enumerator[::Array[Elem], self]
+  def repeated_combination: (int size) { (Array[E] combination) -> void } -> self
+                          | (int size) -> Enumerator[Array[E], self]
 
   # <!--
   #   rdoc-file=array.c
@@ -2896,7 +2993,7 @@ class Array[unchecked out Elem] < Object
   #
   # If a positive integer argument `size` is given, calls the block with each
   # `size`-tuple repeated permutation of the elements of `self`. The number of
-  # permutations is `self.size**size`.
+  # permutations is <code>self.size**size</code>.
   #
   # Examples:
   #
@@ -2922,8 +3019,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def repeated_permutation: (int n) { (::Array[Elem] p) -> void } -> self
-                          | (int n) -> ::Enumerator[::Array[Elem], self]
+  def repeated_permutation: (int size) { (Array[E] permutation) -> void } -> self
+                          | (int size) -> Enumerator[Array[E], self]
 
   # <!-- rdoc-file=array.c -->
   # Replaces the elements of `self` with the elements of `other_array`, which must
@@ -2936,7 +3033,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def replace: (::Array[Elem]) -> self
+  def replace: (array[E] other_array) -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -2948,7 +3045,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def reverse: () -> ::Array[Elem]
+  def reverse: () -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -2962,7 +3059,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def reverse!: () -> ::Array[Elem]
+  def reverse!: () -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -2986,8 +3083,33 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Iterating](rdoc-ref:Array@Methods+for+Iterating).
   #
-  def reverse_each: () { (Elem item) -> void } -> self
-                  | () -> ::Enumerator[Elem, self]
+  def reverse_each: () { (E element) -> void } -> self
+                  | () -> Enumerator[E, self]
+
+  # <!--
+  #   rdoc-file=array.c
+  #   - rfind(if_none_proc = nil) {|element| ... } -> object or nil
+  #   - rfind(if_none_proc = nil) -> enumerator
+  # -->
+  # Returns the last element for which the block returns a truthy value.
+  #
+  # With a block given, calls the block with successive elements of the array in
+  # reverse order; returns the first element for which the block returns a truthy
+  # value:
+  #
+  #     [1, 2, 3, 4, 5, 6].rfind {|element| element < 5}       # => 4
+  #
+  # If no such element is found, calls `if_none_proc` and returns its return
+  # value.
+  #
+  #     [1, 2, 3, 4].rfind(proc {0}) {|element| element < -2}  # => 0
+  #
+  # With no block given, returns an Enumerator.
+  #
+  def rfind: () { (E) -> boolish } -> E?
+           | () -> Enumerator[E, E?]
+           | [T] (Enumerable::_NotFound[T]? ifnone) { (E) -> boolish } -> (E | T)
+           | [T] (Enumerable::_NotFound[T]? ifnone) -> Enumerator[E, E | T]
 
   # <!--
   #   rdoc-file=array.c
@@ -2995,7 +3117,8 @@ class Array[unchecked out Elem] < Object
   #   - rindex {|element| ... } -> integer or nil
   #   - rindex -> new_enumerator
   # -->
-  # Returns the index of the last element for which `object == element`.
+  # Returns the index of the last element for which <code>object ==
+  # element</code>.
   #
   # With argument `object` given, returns the index of the last such element
   # found:
@@ -3017,9 +3140,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
   #
-  def rindex: (untyped obj) -> ::Integer?
-            | () { (Elem item) -> boolish } -> ::Integer?
-            | () -> ::Enumerator[Elem, ::Integer?]
+  def rindex: (untyped object) -> Integer? # where E: _Equal
+            | () { (E element) -> boolish } -> Integer?
+            | () -> Enumerator[E, Integer?]
 
   # <!--
   #   rdoc-file=array.c
@@ -3034,7 +3157,7 @@ class Array[unchecked out Elem] < Object
   #     [0, 1, 2, 3].rotate(2)   # => [2, 3, 0, 1]
   #     [0, 1, 2, 3].rotate(2.1) # => [2, 3, 0, 1]
   #
-  # If `count` is large, uses `count % array.size` as the count:
+  # If `count` is large, uses <code>count % array.size</code> as the count:
   #
   #     [0, 1, 2, 3].rotate(22) # => [2, 3, 0, 1]
   #
@@ -3047,13 +3170,14 @@ class Array[unchecked out Elem] < Object
   #
   #     [0, 1, 2, 3].rotate(-1) # => [3, 0, 1, 2]
   #
-  # If `count` is small (far from zero), uses `count % array.size` as the count:
+  # If `count` is small (far from zero), uses <code>count % array.size</code> as
+  # the count:
   #
   #     [0, 1, 2, 3].rotate(-21) # => [3, 0, 1, 2]
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def rotate: (?int count) -> ::Array[Elem]
+  def rotate: (?int count) -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -3068,7 +3192,7 @@ class Array[unchecked out Elem] < Object
   #     [0, 1, 2, 3].rotate!(2)   # => [2, 3, 0, 1]
   #     [0, 1, 2, 3].rotate!(2.1) # => [2, 3, 0, 1]
   #
-  # If `count` is large, uses `count % array.size` as the count:
+  # If `count` is large, uses <code>count % array.size</code> as the count:
   #
   #     [0, 1, 2, 3].rotate!(21) # => [1, 2, 3, 0]
   #
@@ -3081,7 +3205,8 @@ class Array[unchecked out Elem] < Object
   #
   #     [0, 1, 2, 3].rotate!(-1) # => [3, 0, 1, 2]
   #
-  # If `count` is small (far from zero), uses `count % array.size` as the count:
+  # If `count` is small (far from zero), uses <code>count % array.size</code> as
+  # the count:
   #
   #     [0, 1, 2, 3].rotate!(-21) # => [3, 0, 1, 2]
   #
@@ -3115,7 +3240,7 @@ class Array[unchecked out Elem] < Object
   #
   # The order of the result array is unrelated to the order of `self`.
   #
-  # Returns a new empty `Array` if `self` is empty:
+  # Returns a new empty array if `self` is empty:
   #
   #     [].sample(4) # => []
   #
@@ -3124,8 +3249,8 @@ class Array[unchecked out Elem] < Object
   #     a = [1, 1, 1, 2, 2, 3]
   #     a.sample(a.size) # => [1, 1, 3, 2, 1, 2]
   #
-  # Returns no more than `a.size` elements (because no new duplicates are
-  # introduced):
+  # Returns no more than <code>a.size</code> elements (because no new duplicates
+  # are introduced):
   #
   #     a.sample(50) # => [6, 4, 1, 8, 5, 9, 0, 2, 3, 7]
   #
@@ -3138,8 +3263,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def sample: %a{implicitly-returns-nil} (?random: _Rand rng) -> Elem
-            | (int n, ?random: _Rand rng) -> ::Array[Elem]
+  def sample: %a{implicitly-returns-nil} (?random: _Rand) -> E
+            | (int count, ?random: _Rand) -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -3160,8 +3285,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def select: () { (Elem item) -> boolish } -> ::Array[Elem]
-            | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def select: () { (E element) -> boolish } -> Array[E]
+            | () -> Enumerator[E, Array[E]]
 
   # <!--
   #   rdoc-file=array.c
@@ -3184,8 +3309,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def select!: () { (Elem item) -> boolish } -> self?
-             | () -> ::Enumerator[Elem, self?]
+  def select!: () { (E element) -> boolish } -> self?
+             | () -> Enumerator[E, self?]
 
   # <!--
   #   rdoc-file=array.c
@@ -3223,8 +3348,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def shift: %a{implicitly-returns-nil} () -> Elem
-           | (int n) -> ::Array[Elem]
+  def shift: %a{implicitly-returns-nil} () -> E
+           | (int count) -> Array[E]
 
   # <!--
   #   rdoc-file=array.rb
@@ -3248,7 +3373,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def shuffle: (?random: _Rand rng) -> ::Array[Elem]
+  def shuffle: (?random: _Rand) -> Array[E]
 
   # <!--
   #   rdoc-file=array.rb
@@ -3272,7 +3397,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def shuffle!: (?random: _Rand rng) -> self
+  def shuffle!: (?random: _Rand) -> self
 
   # <!-- rdoc-file=array.c -->
   # Returns the count of elements in `self`:
@@ -3320,50 +3445,52 @@ class Array[unchecked out Elem] < Object
   #
   # If `index` is out of range, returns `nil`.
   #
-  # When two Integer arguments `start` and `length` are given, returns a new
-  # `Array` of size `length` containing successive elements beginning at offset
-  # `start`:
+  # 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:
+  # If <code>start + length</code> is greater than <code>self.length</code>,
+  # returns all elements from offset `start` to the end:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0, 4] # => [:foo, "bar", 2]
   #     a[1, 3] # => ["bar", 2]
   #     a[2, 2] # => [2]
   #
-  # If `start == self.size` and `length >= 0`, returns a new empty `Array`.
+  # If <code>start == self.size</code> and <code>length >= 0</code>, returns a new
+  # empty array.
   #
   # If `length` is negative, returns `nil`.
   #
-  # When a single Range argument `range` is given, treats `range.min` as `start`
-  # above and `range.size` as `length` above:
+  # When a single Range argument `range` is given, treats <code>range.min</code>
+  # as `start` above and <code>range.size</code> as `length` above:
   #
   #     a = [:foo, 'bar', 2]
   #     a[0..1] # => [:foo, "bar"]
   #     a[1..2] # => ["bar", 2]
   #
-  # Special case: If `range.start == a.size`, returns a new empty `Array`.
+  # Special case: If <code>range.start == a.size</code>, returns a new empty
+  # array.
   #
-  # If `range.end` is negative, calculates the end index from the end:
+  # If <code>range.end</code> 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:
+  # If <code>range.start</code> 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`.
+  # If <code>range.start</code> is larger than the array size, returns `nil`.
   #
   #     a = [:foo, 'bar', 2]
   #     a[4..1] # => nil
@@ -3371,7 +3498,7 @@ class Array[unchecked out Elem] < Object
   #     a[4..-1] # => nil
   #
   # When a single Enumerator::ArithmeticSequence argument `aseq` is given, returns
-  # an `Array` of elements corresponding to the indexes produced by the sequence.
+  # an array of elements corresponding to the indexes produced by the sequence.
   #
   #     a = ['--', 'data1', '--', 'data2', '--', 'data3']
   #     a[(1..).step(2)] # => ["data1", "data2", "data3"]
@@ -3394,9 +3521,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def slice: %a{implicitly-returns-nil} (int index) -> Elem
-           | (int start, int length) -> ::Array[Elem]?
-           | (::Range[::Integer] range) -> ::Array[Elem]?
+  alias slice []
 
   # <!--
   #   rdoc-file=array.c
@@ -3445,51 +3570,52 @@ class Array[unchecked out Elem] < Object
   #     a.slice!(5, 1)  # => nil
   #     a.slice!(-5, 1) # => nil
   #
-  # If `start + length` exceeds the array size, removes and returns all elements
-  # from offset `start` to the end:
+  # If <code>start + length</code> exceeds the array size, removes and returns all
+  # elements from offset `start` to the end:
   #
   #     a = ['a', 'b', 'c', 'd']
   #     a.slice!(2, 50) # => ["c", "d"]
   #     a               # => ["a", "b"]
   #
-  # If `start == a.size` and `length` is non-negative, returns a new empty array.
+  # If <code>start == a.size</code> and `length` is non-negative, returns a new
+  # empty array.
   #
   # If `length` is negative, returns `nil`.
   #
-  # With Range argument `range` given, treats `range.min` as `start` (as above)
-  # and `range.size` as `length` (as above):
+  # With Range argument `range` given, treats <code>range.min</code> as `start`
+  # (as above) and <code>range.size</code> as `length` (as above):
   #
   #     a = ['a', 'b', 'c', 'd']
   #     a.slice!(1..2) # => ["b", "c"]
   #     a              # => ["a", "d"]
   #
-  # If `range.start == a.size`, returns a new empty array:
+  # If <code>range.start == a.size</code>, returns a new empty array:
   #
   #     a = ['a', 'b', 'c', 'd']
   #     a.slice!(4..5) # => []
   #
-  # If `range.start` is larger than the array size, returns `nil`:
+  # If <code>range.start</code> is larger than the array size, returns `nil`:
   #
   #     a = ['a', 'b', 'c', 'd']
   #     a.slice!(5..6) # => nil
   #
-  # If `range.start` is negative, calculates the start index by counting backwards
-  # from the end of `self`:
+  # If <code>range.start</code> is negative, calculates the start index by
+  # counting backwards from the end of `self`:
   #
   #     a = ['a', 'b', 'c', 'd']
   #     a.slice!(-2..2) # => ["c"]
   #
-  # If `range.end` is negative, calculates the end index by counting backwards
-  # from the end of `self`:
+  # If <code>range.end</code> is negative, calculates the end index by counting
+  # backwards from the end of `self`:
   #
   #     a = ['a', 'b', 'c', 'd']
   #     a.slice!(0..-2) # => ["a", "b", "c"]
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def slice!: %a{implicitly-returns-nil} (int index) -> Elem
-            | (int start, int length) -> ::Array[Elem]?
-            | (::Range[::Integer] range) -> ::Array[Elem]?
+  def slice!: %a{implicitly-returns-nil} (int index) -> E
+            | (int start, int length) -> Array[E]?
+            | (range[int?] range) -> Array[E]?
 
   # <!--
   #   rdoc-file=array.c
@@ -3498,7 +3624,8 @@ class Array[unchecked out Elem] < Object
   # -->
   # Returns a new array containing the elements of `self`, sorted.
   #
-  # With no block given, compares elements using operator `#<=>` (see Object#<=>):
+  # With no block given, compares elements using operator <code>#<=></code> (see
+  # Object#<=>):
   #
   #     [0, 2, 3, 1].sort # => [0, 1, 2, 3]
   #
@@ -3518,10 +3645,14 @@ class Array[unchecked out Elem] < Object
   # When the block returns zero, the order for `a` and `b` is indeterminate, and
   # may be unstable.
   #
+  # See an example in Numeric#nonzero? for the idiom to sort more complex
+  # structure.
+  #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def sort: () -> ::Array[Elem]
-          | () { (Elem a, Elem b) -> ::Integer } -> ::Array[Elem]
+  def sort: () -> Array[E] # where E: Comparable::_WithSpaceshipOperator
+          | () { (E a, E b) -> Comparable::_CompareToZero } -> Array[E]
+          | %a{warning: returning `nil` will always raise at runtime} () { (E a, E b) -> Comparable::_CompareToZero? } -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -3532,8 +3663,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def sort!: () -> self
-           | () { (Elem a, Elem b) -> ::Integer } -> self
+  def sort!: () -> self # where E: Comparable::_WithSpaceshipOperator
+           | () { (E a, E b) -> Comparable::_CompareToZero } -> self
+           | %a{warning: returning `nil` will always raise at runtime} () { (E a, E b) -> Comparable::_CompareToZero? } -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -3556,8 +3688,9 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def sort_by!: [U] () { (Elem obj) -> U } -> ::Array[Elem]
-              | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def sort_by!: () { (E element) -> Comparable::_WithSpaceshipOperator } -> self
+              | %a{warning: returning `nil` will always raise at runtime} () { (E element) -> Comparable::_WithSpaceshipOperator? } -> self
+              | () -> Enumerator[E, self]
 
   # <!--
   #   rdoc-file=array.c
@@ -3571,7 +3704,8 @@ class Array[unchecked out Elem] < Object
   #     array.each {|element| sum += element }
   #     sum
   #
-  # For example, `[e0, e1, e2].sum` returns `init + e0 + e1 + e2`.
+  # For example, <code>[e0, e1, e2].sum</code> returns <code>init + e0 + e1 +
+  # e2</code>.
   #
   # Examples:
   #
@@ -3582,7 +3716,7 @@ class Array[unchecked out Elem] < Object
   #     # => [2, 3, :foo, :bar, "foo", "bar"]
   #
   # The `init` value and elements need not be numeric, but must all be
-  # `+`-compatible:
+  # <code>+</code>-compatible:
   #
   #     # Raises TypeError: Array can't be coerced into Integer.
   #     [[:foo, :bar], ['foo', 'bar']].sum(2)
@@ -3600,8 +3734,7 @@ class Array[unchecked out Elem] < Object
   # *   Array#sum method may not respect method redefinition of "+" methods such
   #     as Integer#+.
   #
-  def sum: (?untyped init) -> untyped
-         | (?untyped init) { (Elem e) -> untyped } -> untyped
+  def sum: (?untyped init) ?{ (E e) -> untyped } -> untyped # This would be usable if we had `where E < Complex`, etc
 
   # <!--
   #   rdoc-file=array.c
@@ -3618,7 +3751,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def take: (int n) -> ::Array[Elem]
+  def take: (int count) -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -3640,14 +3773,14 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def take_while: () { (Elem obj) -> boolish } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def take_while: () { (E element) -> boolish } -> Array[E]
+                | () -> Enumerator[E, Array[E]]
 
   # <!--
   #   rdoc-file=array.c
   #   - to_a -> self or new_array
   # -->
-  # When `self` is an instance of `Array`, returns `self`.
+  # When `self` is an instance of Array, returns `self`.
   #
   # Otherwise, returns a new array containing the elements of `self`:
   #
@@ -3659,11 +3792,11 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  def to_a: () -> ::Array[Elem]
+  def to_a: () -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
-  #   - array.to_ary -> self
+  #   - to_ary -> self
   # -->
   # Returns `self`.
   #
@@ -3694,11 +3827,11 @@ class Array[unchecked out Elem] < Object
   # Related: see [Methods for Converting](rdoc-ref:Array@Methods+for+Converting).
   #
   def to_h: () -> Hash[untyped, untyped]
-          | [T, S] () { (Elem) -> [ T, S ] } -> Hash[T, S]
+          | [K, V] () { (E element) -> Hash::_Pair[K, V] } -> Hash[K, V]
 
   # <!-- rdoc-file=array.c -->
-  # Returns the new string formed by calling method `#inspect` on each array
-  # element:
+  # Returns the new string formed by calling method <code>#inspect</code> on each
+  # array element:
   #
   #     a = [:foo, 'bar', 2]
   #     a.inspect # => "[:foo, \"bar\", 2]"
@@ -3721,14 +3854,14 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  def transpose: () -> ::Array[::Array[untyped]]
+  def transpose: () -> Array[Array[untyped]]
 
   # <!--
   #   rdoc-file=array.c
   #   - union(*other_arrays) -> new_array
   # -->
   # Returns a new array that is the union of the elements of `self` and all given
-  # arrays `other_arrays`; items are compared using `eql?`:
+  # arrays `other_arrays`; items are compared using <code>eql?</code>:
   #
   #     [0, 1, 2, 3].union([4, 5], [6, 7]) # => [0, 1, 2, 3, 4, 5, 6, 7]
   #
@@ -3744,7 +3877,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def union: [T] (*::Array[T] other_arys) -> ::Array[T | Elem]
+  def union: [T] (*array[T] other_arrays) -> Array[T | E] # where E: _Eql?[T]
 
   # <!--
   #   rdoc-file=array.c
@@ -3755,23 +3888,23 @@ class Array[unchecked out Elem] < Object
   # duplicates, the first occurrence always being retained.
   #
   # With no block given, identifies and omits duplicate elements using method
-  # `eql?` to compare elements:
+  # <code>eql?</code> to compare elements:
   #
   #     a = [0, 0, 1, 1, 2, 2]
   #     a.uniq # => [0, 1, 2]
   #
   # With a block given, calls the block for each element; identifies and omits
-  # "duplicate" elements using method `eql?` to compare *block return values*;
-  # that is, an element is a duplicate if its block return value is the same as
-  # that of a previous element:
+  # "duplicate" elements using method <code>eql?</code> to compare *block return
+  # values*; that is, an element is a duplicate if its block return value is the
+  # same as that of a previous element:
   #
   #     a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb']
   #     a.uniq {|element| element.size } # => ["a", "aa", "aaa"]
   #
   # Related: [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def uniq: () -> ::Array[Elem]
-          | () { (Elem item) -> untyped } -> ::Array[Elem]
+  def uniq: () -> Array[E] # where E: Hash::_Key
+          | () { (E element) -> Hash::_Key } -> Array[E]
 
   # <!--
   #   rdoc-file=array.c
@@ -3781,17 +3914,17 @@ class Array[unchecked out Elem] < Object
   # Removes duplicate elements from `self`, the first occurrence always being
   # retained; returns `self` if any elements removed, `nil` otherwise.
   #
-  # With no block given, identifies and removes elements using method `eql?` to
-  # compare elements:
+  # With no block given, identifies and removes elements using method
+  # <code>eql?</code> to compare elements:
   #
   #     a = [0, 0, 1, 1, 2, 2]
   #     a.uniq! # => [0, 1, 2]
   #     a.uniq! # => nil
   #
   # With a block given, calls the block for each element; identifies and omits
-  # "duplicate" elements using method `eql?` to compare *block return values*;
-  # that is, an element is a duplicate if its block return value is the same as
-  # that of a previous element:
+  # "duplicate" elements using method <code>eql?</code> to compare *block return
+  # values*; that is, an element is a duplicate if its block return value is the
+  # same as that of a previous element:
   #
   #     a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb']
   #     a.uniq! {|element| element.size } # => ["a", "aa", "aaa"]
@@ -3799,8 +3932,8 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Deleting](rdoc-ref:Array@Methods+for+Deleting).
   #
-  def uniq!: () -> self?
-           | () { (Elem) -> untyped } -> self?
+  def uniq!: () -> self? # where E: Hash::_Key
+           | () { (E element) -> Hash::_Key } -> self?
 
   # <!--
   #   rdoc-file=array.c
@@ -3815,7 +3948,7 @@ class Array[unchecked out Elem] < Object
   # Related: Array#shift; see also [Methods for
   # Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def unshift: (*Elem obj) -> self
+  def unshift: (*E objects) -> self
 
   # <!--
   #   rdoc-file=array.c
@@ -3857,13 +3990,13 @@ class Array[unchecked out Elem] < Object
   # For each numeric specifier `index`, includes an element:
   #
   # *   For each non-negative numeric specifier `index` that is in-range (less
-  #     than `self.size`), includes the element at offset `index`:
+  #     than <code>self.size</code>), includes the element at offset `index`:
   #
   #         a.values_at(0, 2)     # => ["a", "c"]
   #         a.values_at(0.1, 2.9) # => ["a", "c"]
   #
   # *   For each negative numeric `index` that is in-range (greater than or equal
-  #     to `- self.size`), counts backwards from the end of `self`:
+  #     to <code>- self.size</code>), counts backwards from the end of `self`:
   #
   #         a.values_at(-1, -4) # => ["d", "a"]
   #
@@ -3875,37 +4008,41 @@ class Array[unchecked out Elem] < Object
   #
   #     a.values_at(4, -5) # => [nil, nil]
   #
-  # For each Range specifier `range`, includes elements according to `range.begin`
-  # and `range.end`:
+  # For each Range specifier `range`, includes elements according to
+  # <code>range.begin</code> and <code>range.end</code>:
   #
-  # *   If both `range.begin` and `range.end` are non-negative and in-range (less
-  #     than `self.size`), includes elements from index `range.begin` through
-  #     `range.end - 1` (if `range.exclude_end?`), or through `range.end`
-  #     (otherwise):
+  # *   If both <code>range.begin</code> and <code>range.end</code> are
+  #     non-negative and in-range (less than <code>self.size</code>), includes
+  #     elements from index <code>range.begin</code> through <code>range.end -
+  #     1</code> (if <code>range.exclude_end?</code>), or through
+  #     <code>range.end</code> (otherwise):
   #
   #         a.values_at(1..2)  # => ["b", "c"]
   #         a.values_at(1...2) # => ["b"]
   #
-  # *   If `range.begin` is negative and in-range (greater than or equal to `-
-  #     self.size`), counts backwards from the end of `self`:
+  # *   If <code>range.begin</code> is negative and in-range (greater than or
+  #     equal to <code>- self.size</code>), counts backwards from the end of
+  #     `self`:
   #
   #         a.values_at(-2..3) # => ["c", "d"]
   #
-  # *   If `range.begin` is negative and out-of-range, raises an exception:
+  # *   If <code>range.begin</code> is negative and out-of-range, raises an
+  #     exception:
   #
   #         a.values_at(-5..3) # Raises RangeError.
   #
-  # *   If `range.end` is positive and out-of-range, extends the returned array
-  #     with `nil` elements:
+  # *   If <code>range.end</code> is positive and out-of-range, extends the
+  #     returned array with `nil` elements:
   #
   #         a.values_at(1..5) # => ["b", "c", "d", nil, nil]
   #
-  # *   If `range.end` is negative and in-range, counts backwards from the end of
-  #     `self`:
+  # *   If <code>range.end</code> is negative and in-range, counts backwards from
+  #     the end of `self`:
   #
   #         a.values_at(1..-2) # => ["b", "c"]
   #
-  # *   If `range.end` is negative and out-of-range, returns an empty array:
+  # *   If <code>range.end</code> is negative and out-of-range, returns an empty
+  #     array:
   #
   #         a.values_at(1..-5) # => []
   #
@@ -3919,7 +4056,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
   #
-  def values_at: (*int | ::Range[::Integer] selector) -> ::Array[Elem?]
+  def values_at: (*int | range[int?] selector) -> Array[E?]
 
   # <!--
   #   rdoc-file=array.c
@@ -3934,8 +4071,8 @@ class Array[unchecked out Elem] < Object
   #
   # Returned:
   #
-  # *   The outer array is of size `self.size`.
-  # *   Each sub-array is of size `other_arrays.size + 1`.
+  # *   The outer array is of size <code>self.size</code>.
+  # *   Each sub-array is of size <code>other_arrays.size + 1</code>.
   # *   The *nth* sub-array contains (in order):
   #
   #     *   The *nth* element of `self`.
@@ -4008,22 +4145,26 @@ class Array[unchecked out Elem] < Object
   #      [:c3, :b3, :a3]]
   #
   # For an **object** in **other_arrays** that is not actually an array, forms the
-  # the "other array" as `object.to_ary`, if defined, or as `object.each.to_a`
-  # otherwise.
+  # "other array" as <code>object.to_ary</code>, if defined, or as
+  # <code>object.each.to_a</code> otherwise.
   #
   # Related: see [Methods for Converting](rdoc-ref:Array@Methods+for+Converting).
   #
-  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
+  def zip: () -> Array[[ E ]]
+         | [X] (_Each[X] iterable) -> Array[[ E, X? ]]
+         | [X, Y] (_Each[X] iterable1, _Each[Y] iterable2) -> Array[[ E, X?, Y? ]]
+         | [U] (*_Each[U] iterables) -> Array[Array[E | U?]]
+         | () { ([ E ]) -> void } -> nil
+         | [X] (_Each[X] iterable) { ([ E, X? ]) -> void } -> nil
+         | [X, Y] (_Each[X] iterable1, _Each[Y] iterable2) { ([ E, X?, Y? ]) -> void } -> nil
+         | [U] (*_Each[U] iterables) { (Array[E | U?]) -> void } -> nil
 
   # <!--
   #   rdoc-file=array.c
   #   - self | other_array -> new_array
   # -->
   # Returns the union of `self` and `other_array`; duplicates are removed; order
-  # is preserved; items are compared using `eql?`:
+  # is preserved; items are compared using <code>eql?</code>:
   #
   #     [0, 1] | [2, 3] # => [0, 1, 2, 3]
   #     [0, 1, 1] | [2, 2, 3] # => [0, 1, 2, 3]
@@ -4031,7 +4172,7 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Combining](rdoc-ref:Array@Methods+for+Combining).
   #
-  def |: [T] (::Array[T] other_ary) -> ::Array[Elem | T]
+  def |: [T] (array[T] other_array) -> Array[E | T] # where E: _Eql?[T]
 
   private
 
@@ -4050,13 +4191,15 @@ class Array[unchecked out Elem] < Object
   #
   # Related: see [Methods for Assigning](rdoc-ref:Array@Methods+for+Assigning).
   #
-  def initialize_copy: (self other_ary) -> void
+  alias initialize_copy replace
 end
 
+%a{deprecated: Use Array::_Rand, or make your own}
 interface _Rand
-  def rand: (::Integer max) -> ::Integer
+  def rand: (Integer max) -> Integer
 end
 
+%a{deprecated: Use RBS::Ops::_CaseEqual[E, boolish]}
 interface Array::_Pattern[T]
   def ===: (T) -> bool
 end