rbs 3.9.4 → 4.1.1

data/core/enumerable.rbs

@@ -16,8 +16,8 @@
 # These methods return information about the Enumerable other than the elements
 # themselves:
 #
-# *   #member? (aliased as #include?): Returns `true` if `self == object`,
-#     `false` otherwise.
+# *   #member? (aliased as #include?): Returns `true` if <code>self ==
+#     object</code>, `false` otherwise.
 # *   #all?: Returns `true` if all elements meet a specified criterion; `false`
 #     otherwise.
 # *   #any?: Returns `true` if any element meets a specified criterion; `false`
@@ -35,7 +35,7 @@
 #
 # These methods return entries from the Enumerable, without modifying it:
 #
-# *Leading, trailing, or all elements*:
+# <em>Leading, trailing, or all elements</em>:
 #
 # *   #to_a (aliased as #entries): Returns all elements.
 # *   #first: Returns the first element or leading elements.
@@ -47,9 +47,9 @@
 # *Minimum and maximum value elements*:
 #
 # *   #min: Returns the elements whose values are smallest among the elements,
-#     as determined by `#<=>` or a given block.
+#     as determined by <code>#<=></code> or a given block.
 # *   #max: Returns the elements whose values are largest among the elements, as
-#     determined by `#<=>` or a given block.
+#     determined by <code>#<=></code> or a given block.
 # *   #minmax: Returns a 2-element Array containing the smallest and largest
 #     elements.
 # *   #min_by: Returns the smallest element, as determined by the given block.
@@ -57,7 +57,7 @@
 # *   #minmax_by: Returns the smallest and largest elements, as determined by
 #     the given block.
 #
-# *Groups, slices, and partitions*:
+# <em>Groups, slices, and partitions</em>:
 #
 # *   #group_by: Returns a Hash that partitions the elements into groups.
 # *   #partition: Returns elements partitioned into two new Arrays, as
@@ -89,7 +89,8 @@
 #
 # These methods return elements in sorted order:
 #
-# *   #sort: Returns the elements, sorted by `#<=>` or the given block.
+# *   #sort: Returns the elements, sorted by <code>#<=></code> or the given
+#     block.
 # *   #sort_by: Returns the elements, sorted by the given block.
 #
 # ### Methods for Iterating
@@ -114,11 +115,11 @@
 #     by the block.
 # *   #grep: Returns elements selected by a given object or objects returned by
 #     a given block.
-# *   #grep_v: Returns elements selected by a given object or objects returned
-#     by a given block.
+# *   #grep_v: Returns elements not selected by a given object or objects
+#     returned by a given block.
 # *   #inject (aliased as #reduce): Returns the object formed by combining all
 #     elements.
-# *   #sum: Returns the sum of the elements, using method `+`.
+# *   #sum: Returns the sum of the elements, using method <code>+</code>.
 # *   #zip: Combines each element with elements from other enumerables; returns
 #     the n-tuples or calls the block with each.
 # *   #cycle: Calls the block with each element, cycling repeatedly.
@@ -131,8 +132,9 @@
 #
 #         include Enumerable
 #
-# *   Implement method `#each` which must yield successive elements of the
-#     collection. The method will be called by almost any Enumerable method.
+# *   Implement method <code>#each</code> which must yield successive elements
+#     of the collection. The method will be called by almost any Enumerable
+#     method.
 #
 # Example:
 #
@@ -173,13 +175,15 @@
 # *   CSV::Row
 # *   Set
 #
-# Virtually all methods in Enumerable call method `#each` in the including
-# class:
+# Virtually all methods in Enumerable call method <code>#each</code> in the
+# including class:
 #
-# *   `Hash#each` yields the next key-value pair as a 2-element Array.
-# *   `Struct#each` yields the next name-value pair as a 2-element Array.
-# *   For the other classes above, `#each` yields the next object from the
-#     collection.
+# *   <code>Hash#each</code> yields the next key-value pair as a 2-element
+#     Array.
+# *   <code>Struct#each</code> yields the next name-value pair as a 2-element
+#     Array.
+# *   For the other classes above, <code>#each</code> yields the next object
+#     from the collection.
 #
 # ## About the Examples
 #
@@ -191,7 +195,88 @@
 #     usage would not make sense, and so it is not shown.  Example: #tally would
 #     find exactly one of each Hash entry.
 #
-module Enumerable[unchecked out Elem] : _Each[Elem]
+# ## Extended Methods
+#
+# A Enumerable class may define extended methods. This section describes the
+# standard behavior of extension methods for reference purposes.
+#
+# ### #size
+#
+# Enumerator has a #size method. It uses the size function argument passed to
+# <code>Enumerator.new</code>.
+#
+#     e = Enumerator.new(-> { 3 }) {|y| p y; y.yield :a; y.yield :b; y.yield :c; :z }
+#     p e.size #=> 3
+#     p e.next #=> :a
+#     p e.next #=> :b
+#     p e.next #=> :c
+#     begin
+#       e.next
+#     rescue StopIteration
+#       p $!.result #=> :z
+#     end
+#
+# The result of the size function should represent the number of iterations
+# (i.e., the number of times Enumerator::Yielder#yield is called). In the above
+# example, the block calls #yield three times, and the size function, +-> { 3
+# }+, returns 3 accordingly. The result of the size function can be an integer,
+# <code>Float::INFINITY</code>, or `nil`. An integer means the exact number of
+# times #yield will be called, as shown above. <code>Float::INFINITY</code>
+# indicates an infinite number of #yield calls. `nil` means the number of #yield
+# calls is difficult or impossible to determine.
+#
+# Many iteration methods return an Enumerator object with an appropriate size
+# function if no block is given.
+#
+# Examples:
+#
+#     ["a", "b", "c"].each.size #=> 3
+#     {a: "x", b: "y", c: "z"}.each.size #=> 3
+#     (0..20).to_a.permutation.size #=> 51090942171709440000
+#     loop.size #=> Float::INFINITY
+#     (1..100).drop_while.size #=> nil  # size depends on the block's behavior
+#     STDIN.each.size #=> nil # cannot be computed without consuming input
+#     File.open("/etc/resolv.conf").each.size #=> nil # cannot be computed without reading the file
+#
+# The behavior of #size for Range-based enumerators depends on the #begin
+# element:
+#
+# *   If the #begin element is an Integer, the #size method returns an Integer
+#     or <code>Float::INFINITY</code>.
+# *   If the #begin element is an object with a #succ method (other than
+#     Integer), #size returns `nil`. (Computing the size would require
+#     repeatedly calling #succ, which may be too slow.)
+# *   If the #begin element does not have a #succ method, #size raises a
+#     TypeError.
+#
+# Examples:
+#
+#     (10..42).each.size #=> 33
+#     (10..42.9).each.size #=> 33 (the #end element may be a non-integer numeric)
+#     (10..).each.size #=> Float::INFINITY
+#     ("a".."z").each.size #=> nil
+#     ("a"..).each.size #=> nil
+#     (1.0..9.0).each.size # raises TypeError (Float does not have #succ)
+#     (..10).each.size # raises TypeError (beginless range has nil as its #begin)
+#
+# The Enumerable module itself does not define a #size method. A class that
+# includes Enumerable may define its own #size method. It is recommended that
+# such a #size method be consistent with Enumerator#size.
+#
+# Array and Hash implement #size and return values consistent with
+# Enumerator#size. IO and Dir do not define #size, which is also consistent
+# because the corresponding enumerator's size function returns `nil`.
+#
+# However, it is not strictly required for a class's #size method to match
+# Enumerator#size. For example, File#size returns the number of bytes in the
+# file, not the number of lines.
+#
+module Enumerable[unchecked out E] : _Each[E]
+  %a{private}
+  interface _Pattern
+    def ===: (untyped) -> bool
+  end
+
   # <!--
   #   rdoc-file=enum.c
   #   - all?                  -> true or false
@@ -211,7 +296,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     [].all?               # => true
   #
   # With argument `pattern` and no block, returns whether for each element
-  # `element`, `pattern === element`:
+  # `element`, <code>pattern === element</code>:
   #
   #     (1..4).all?(Integer)                 # => true
   #     (1..4).all?(Numeric)                 # => true
@@ -234,7 +319,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Related: #any?, #none? #one?.
   #
   def all?: () -> bool
-          | () { (Elem) -> boolish } -> bool
+          | (_Pattern) -> bool
+          | () { (E) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=enum.c
@@ -254,7 +340,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     [].any?              # => false
   #
   # With argument `pattern` and no block, returns whether for any element
-  # `element`, `pattern === element`:
+  # `element`, <code>pattern === element</code>:
   #
   #     [nil, false, 0].any?(Integer)        # => true
   #     [nil, false, 0].any?(Numeric)        # => true
@@ -277,7 +363,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Related: #all?, #none?, #one?.
   #
   def any?: () -> bool
-          | () { (Elem) -> boolish } -> bool
+          | (_Pattern) -> bool
+          | () { (E) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=enum.c
@@ -294,8 +381,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def collect: [U] () { (Elem arg0) -> U } -> ::Array[U]
-             | () -> ::Enumerator[Elem, ::Array[untyped]]
+  def collect: [U] () { (E arg0) -> U } -> ::Array[U]
+             | () -> ::Enumerator[E, ::Array[untyped]]
 
   # <!-- rdoc-file=enum.c -->
   # Returns an array of flattened objects returned by the block.
@@ -312,8 +399,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Alias: #collect_concat.
   #
-  def collect_concat: [U] () { (Elem) -> (::Array[U] | U) } -> ::Array[U]
-                    | () -> ::Enumerator[Elem, ::Array[untyped]]
+  def collect_concat: [U] () { (E) -> (::Array[U] | U) } -> ::Array[U]
+                    | () -> ::Enumerator[E, ::Array[untyped]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -324,7 +411,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     a = [nil, 0, nil, 'a', false, nil, false, nil, 'a', nil, 0, nil]
   #     a.compact # => [0, "a", false, false, "a", 0]
   #
-  def compact: () -> Array[Elem]
+  def compact: () -> Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -340,8 +427,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     [0, 1, 2].count                # => 3
   #     {foo: 0, bar: 1, baz: 2}.count # => 3
   #
-  # With argument `object` given, returns the number of elements that are `==` to
-  # `object`:
+  # With argument `object` given, returns the number of elements that are
+  # <code>==</code> to `object`:
   #
   #     [0, 1, 2, 1].count(1)           # => 2
   #
@@ -352,8 +439,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     {foo: 0, bar: 1, baz: 2}.count {|key, value| value < 2} # => 2
   #
   def count: () -> Integer
-           | (Elem) -> Integer
-           | () { (Elem) -> boolish } -> Integer
+           | (E) -> Integer
+           | () { (E) -> boolish } -> Integer
 
   # <!--
   #   rdoc-file=enum.c
@@ -380,8 +467,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # When no block is given, returns an Enumerator.
   #
-  def cycle: (?Integer n) { (Elem arg0) -> untyped } -> NilClass
-           | (?Integer n) -> ::Enumerator[Elem, NilClass]
+  def cycle: (?Integer n) { (E arg0) -> untyped } -> NilClass
+           | (?Integer n) -> ::Enumerator[E, NilClass]
 
   # <!-- rdoc-file=enum.c -->
   # Returns the first element for which the block returns a truthy value.
@@ -401,8 +488,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def detect: (?Proc ifnone) { (Elem) -> boolish } -> Elem?
-            | (?Proc ifnone) -> ::Enumerator[Elem, Elem?]
+  def detect: (?Proc ifnone) { (E) -> boolish } -> E?
+            | (?Proc ifnone) -> ::Enumerator[E, E?]
 
   # <!--
   #   rdoc-file=enum.c
@@ -421,7 +508,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     h = {foo: 0, bar: 1, baz: 2, bat: 3}
   #     h.drop(2) # => [[:baz, 2], [:bat, 3]]
   #
-  def drop: (Integer n) -> ::Array[Elem]
+  def drop: (Integer n) -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -438,8 +525,19 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def drop_while: () { (Elem) -> boolish } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, ::Array[Elem]]
+  #     e = (1..4).drop_while
+  #     p e #=> #<Enumerator: 1..4:drop_while>
+  #     i = e.next; p i; e.feed(i < 3) #=> 1
+  #     i = e.next; p i; e.feed(i < 3) #=> 2
+  #     i = e.next; p i; e.feed(i < 3) #=> 3
+  #     begin
+  #       e.next
+  #     rescue StopIteration
+  #       p $!.result #=> [3, 4]
+  #     end
+  #
+  def drop_while: () { (E) -> boolish } -> ::Array[E]
+                | () -> ::Enumerator[E, ::Array[E]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -460,16 +558,16 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def each_cons: (Integer n) { (::Array[Elem]) -> void } -> self
-               | (Integer n) -> ::Enumerator[::Array[Elem], self]
+  def each_cons: (Integer n) { (::Array[E]) -> void } -> self
+               | (Integer n) -> ::Enumerator[::Array[E], self]
 
   # <!--
   #   rdoc-file=enum.c
   #   - each_with_index(*args) {|element, i| ..... } -> self
   #   - each_with_index(*args)                       -> enumerator
   # -->
-  # Invoke `self.each` with `*args`. With a block given, the block receives each
-  # element and its index; returns `self`:
+  # Invoke <code>self.each</code> with <code>*args</code>. With a block given, the
+  # block receives each element and its index; returns `self`:
   #
   #     h = {}
   #     (1..4).each_with_index {|element, i| h[element] = i } # => 1..4
@@ -488,8 +586,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def each_with_index: () { (Elem, Integer index) -> untyped } -> self
-                     | () -> ::Enumerator[[ Elem, Integer ], self]
+  def each_with_index: () { (E, Integer index) -> untyped } -> self
+                     | () -> ::Enumerator[[ E, Integer ], self]
 
   # <!--
   #   rdoc-file=enum.c
@@ -507,18 +605,18 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def each_with_object: [U] (U obj) { (Elem, U obj) -> untyped } -> U
-                      | [U] (U obj) -> ::Enumerator[[ Elem, U ], U]
+  def each_with_object: [U] (U obj) { (E, U obj) -> untyped } -> U
+                      | [U] (U obj) -> ::Enumerator[[ E, U ], U]
 
   # <!-- rdoc-file=enum.c -->
   # Returns an array containing the items in `self`:
   #
   #     (0..4).to_a # => [0, 1, 2, 3, 4]
   #
-  def entries: () -> ::Array[Elem]
+  def entries: () -> ::Array[E]
 
   def enum_for: (Symbol method, *untyped, **untyped) ?{ (?) -> Integer } -> Enumerator[untyped, untyped]
-              | () ?{ () -> Integer } -> Enumerator[Elem, self]
+              | () ?{ () -> Integer } -> Enumerator[E, self]
 
   %a{annotate:rdoc:skip}
   alias to_enum enum_for
@@ -541,8 +639,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #reject.
   #
-  def find_all: () { (Elem) -> boolish } -> ::Array[Elem]
-              | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def find_all: () { (E) -> boolish } -> ::Array[E]
+              | () -> ::Enumerator[E, ::Array[E]]
 
   # <!-- rdoc-file=enum.c -->
   # Returns an array containing elements selected by the block.
@@ -586,7 +684,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # `nil` if no such element is found.
   #
   # With argument `object` given, returns the index of the first element that is
-  # `==` `object`:
+  # <code>==</code> `object`:
   #
   #     ['a', 'b', 'c', 'b'].find_index('b') # => 1
   #
@@ -599,8 +697,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # With no argument and no block given, returns an Enumerator.
   #
   def find_index: (untyped value) -> Integer?
-                | () { (Elem) -> boolish } -> Integer?
-                | () -> ::Enumerator[Elem, Integer?]
+                | () { (E) -> boolish } -> Integer?
+                | () -> ::Enumerator[E, Integer?]
 
   # <!--
   #   rdoc-file=enum.c
@@ -625,8 +723,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     {foo: 1, bar: 1, baz: 2}.first(2) # => [[:foo, 1], [:bar, 1]]
   #     [].first(2)                       # => []
   #
-  def first: () -> Elem?
-           | (_ToInt n) -> ::Array[Elem]
+  def first: () -> E?
+           | (_ToInt n) -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -637,7 +735,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # pattern.
   #
   # With no block given, returns an array containing each element for which
-  # `pattern === element` is `true`:
+  # <code>pattern === element</code> is `true`:
   #
   #     a = ['foo', 'bar', 'car', 'moo']
   #     a.grep(/ar/)                   # => ["bar", "car"]
@@ -652,19 +750,19 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #grep_v.
   #
-  def grep: (untyped arg0) -> ::Array[Elem]
-          | [U] (untyped arg0) { (Elem arg0) -> U } -> ::Array[U]
+  def grep: (untyped arg0) -> ::Array[E]
+          | [U] (untyped arg0) { (E arg0) -> U } -> ::Array[U]
 
   # <!--
   #   rdoc-file=enum.c
   #   - grep_v(pattern) -> array
   #   - grep_v(pattern) {|element| ... } -> array
   # -->
-  # Returns an array of objects based on elements of `self` that *don't* match the
-  # given pattern.
+  # Returns an array of objects based on elements of `self` that <em>don't</em>
+  # match the given pattern.
   #
   # With no block given, returns an array containing each element for which
-  # `pattern === element` is `false`:
+  # <code>pattern === element</code> is `false`:
   #
   #     a = ['foo', 'bar', 'car', 'moo']
   #     a.grep_v(/ar/)                   # => ["foo", "moo"]
@@ -679,8 +777,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #grep.
   #
-  def grep_v: (untyped) -> ::Array[Elem]
-            | [U] (untyped) { (Elem) -> U } -> ::Array[U]
+  def grep_v: (untyped) -> ::Array[E]
+            | [U] (untyped) { (E) -> U } -> ::Array[U]
 
   # <!--
   #   rdoc-file=enum.c
@@ -703,11 +801,11 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def group_by: [U] () { (Elem arg0) -> U } -> ::Hash[U, ::Array[Elem]]
-              | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def group_by: [U] () { (E arg0) -> U } -> ::Hash[U, ::Array[E]]
+              | () -> ::Enumerator[E, ::Array[E]]
 
   # <!-- rdoc-file=enum.c -->
-  # Returns whether for any element `object == element`:
+  # Returns whether for any element <code>object == element</code>:
   #
   #     (1..4).include?(2)                       # => true
   #     (1..4).include?(5)                       # => false
@@ -718,7 +816,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     {foo: 0, bar: 1, baz: 2}.include?('foo') # => false
   #     {foo: 0, bar: 1, baz: 2}.include?(0)     # => false
   #
-  def include?: (Elem arg0) -> bool
+  def include?: (top arg0) -> bool
 
   # <!--
   #   rdoc-file=enum.c
@@ -765,13 +863,13 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     product #=> 24
   #
   # When this runs, the block is first called with `1` (the initial value) and `2`
-  # (the first element of the array). The block returns `1*2`, so on the next
-  # iteration the block is called with `2` (the previous result) and `3`. The
-  # block returns `6`, and is called one last time with `6` and `4`. The result of
-  # the block, `24` becomes the value returned by `inject`. This code returns the
-  # product of the elements in the enumerable.
+  # (the first element of the array). The block returns <code>1*2</code>, so on
+  # the next iteration the block is called with `2` (the previous result) and `3`.
+  # The block returns `6`, and is called one last time with `6` and `4`. The
+  # result of the block, `24` becomes the value returned by `inject`. This code
+  # returns the product of the elements in the enumerable.
   #
-  # **First Shortcut: Default Initial value**
+  # <strong>First Shortcut: Default Initial value</strong>
   #
   # In the case of the previous example, the initial value, `1`, wasn't really
   # necessary: the calculation of the product of a list of numbers is
@@ -808,7 +906,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Note that the last line of the block is just the word `counts`. This ensures
   # the return value of the block is the result that's being calculated.
   #
-  # **Second Shortcut: a Reducer function**
+  # <strong>Second Shortcut: a Reducer function</strong>
   #
   # A *reducer function* is a function that takes a partial result and the next
   # value, returning the next partial result. The block that is given to `inject`
@@ -853,11 +951,11 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     position = "nnneesw".chars.reduce(Turtle.new, :move)
   #     position  #=>> #<Turtle:0x00000001052f4698 @y=2, @x=1>
   #
-  # **Third Shortcut: Reducer With no Initial Value**
+  # <strong>Third Shortcut: Reducer With no Initial Value</strong>
   #
   # If your reducer returns a value that it can accept as a parameter, then you
-  # don't have to pass in an initial value. Here `:*` is the name of the *times*
-  # function:
+  # don't have to pass in an initial value. Here <code>:*</code> is the name of
+  # the *times* function:
   #
   #     product = [ 2, 3, 4 ].inject(:*)
   #     product # => 24
@@ -874,8 +972,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   def inject: (untyped init, Symbol method) -> untyped
             | (Symbol method) -> untyped
-            | [A] (A initial) { (A, Elem) -> A } -> A
-            | () { (Elem, Elem) -> Elem } -> Elem
+            | [A] (A initial) { (A, E) -> A } -> A
+            | () { (E, E) -> E } -> E
 
   # <!--
   #   rdoc-file=enum.c
@@ -888,7 +986,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # The ordering of equal elements is indeterminate and may be unstable.
   #
   # With no argument and no block, returns the maximum element, using the
-  # elements' own method `#<=>` for comparison:
+  # elements' own method <code>#<=></code> for comparison:
   #
   #     (1..4).max                   # => 4
   #     (-4..-1).max                 # => -1
@@ -908,9 +1006,9 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # With a block given, the block determines the maximum elements. The block is
   # called with two elements `a` and `b`, and must return:
   #
-  # *   A negative integer if `a < b`.
-  # *   Zero if `a == b`.
-  # *   A positive integer if `a > b`.
+  # *   A negative integer if <code>a < b</code>.
+  # *   Zero if <code>a == b</code>.
+  # *   A positive integer if <code>a > b</code>.
   #
   # With a block given and no argument, returns the maximum element as determined
   # by the block:
@@ -932,10 +1030,10 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #min, #minmax, #max_by.
   #
-  def max: () -> Elem?
-         | () { (Elem arg0, Elem arg1) -> Integer } -> Elem?
-         | (Integer arg0) -> ::Array[Elem]
-         | (Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
+  def max: () -> E?
+         | () { (E arg0, E arg1) -> Integer } -> E?
+         | (Integer arg0) -> ::Array[E]
+         | (Integer arg0) { (E arg0, E arg1) -> Integer } -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -970,10 +1068,10 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #max, #minmax, #min_by.
   #
-  def max_by: () -> ::Enumerator[Elem, Elem?]
-            | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
-            | (Integer arg0) -> ::Enumerator[Elem, ::Array[Elem]]
-            | (Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
+  def max_by: () -> ::Enumerator[E, E?]
+            | () { (E arg0) -> (Comparable | ::Array[untyped]) } -> E?
+            | (Integer arg0) -> ::Enumerator[E, ::Array[E]]
+            | (Integer arg0) { (E arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -986,7 +1084,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # The ordering of equal elements is indeterminate and may be unstable.
   #
   # With no argument and no block, returns the minimum element, using the
-  # elements' own method `#<=>` for comparison:
+  # elements' own method <code>#<=></code> for comparison:
   #
   #     (1..4).min                   # => 1
   #     (-4..-1).min                 # => -4
@@ -1006,9 +1104,9 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # With a block given, the block determines the minimum elements. The block is
   # called with two elements `a` and `b`, and must return:
   #
-  # *   A negative integer if `a < b`.
-  # *   Zero if `a == b`.
-  # *   A positive integer if `a > b`.
+  # *   A negative integer if <code>a < b</code>.
+  # *   Zero if <code>a == b</code>.
+  # *   A positive integer if <code>a > b</code>.
   #
   # With a block given and no argument, returns the minimum element as determined
   # by the block:
@@ -1030,10 +1128,10 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #min_by, #minmax, #max.
   #
-  def min: () -> Elem?
-         | () { (Elem arg0, Elem arg1) -> Integer } -> Elem?
-         | (Integer arg0) -> ::Array[Elem]
-         | (Integer arg0) { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
+  def min: () -> E?
+         | () { (E arg0, E arg1) -> Integer } -> E?
+         | (Integer arg0) -> ::Array[E]
+         | (Integer arg0) { (E arg0, E arg1) -> Integer } -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1068,10 +1166,10 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #min, #minmax, #max_by.
   #
-  def min_by: () -> ::Enumerator[Elem, Elem?]
-            | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> Elem?
-            | (Integer arg0) -> ::Enumerator[Elem, ::Array[Elem]]
-            | (Integer arg0) { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
+  def min_by: () -> ::Enumerator[E, E?]
+            | () { (E arg0) -> (Comparable | ::Array[untyped]) } -> E?
+            | (Integer arg0) -> ::Enumerator[E, ::Array[E]]
+            | (Integer arg0) { (E arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1083,7 +1181,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # indeterminate and may be unstable.
   #
   # With no argument and no block, returns the minimum and maximum elements, using
-  # the elements' own method `#<=>` for comparison:
+  # the elements' own method <code>#<=></code> for comparison:
   #
   #     (1..4).minmax                   # => [1, 4]
   #     (-4..-1).minmax                 # => [-4, -1]
@@ -1102,8 +1200,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #min, #max, #minmax_by.
   #
-  def minmax: () -> [ Elem?, Elem? ]
-            | () { (Elem arg0, Elem arg1) -> Integer } -> [ Elem?, Elem? ]
+  def minmax: () -> [ E?, E? ]
+            | () { (E arg0, E arg1) -> Integer } -> [ E?, E? ]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1126,8 +1224,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #max_by, #minmax, #min_by.
   #
-  def minmax_by: () -> [ Elem?, Elem? ]
-               | () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> [ Elem?, Elem? ]
+  def minmax_by: () -> [ E?, E? ]
+               | () { (E arg0) -> (Comparable | ::Array[untyped]) } -> [ E?, E? ]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1146,7 +1244,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     [].none?               # => true
   #
   # With argument `pattern` and no block, returns whether for no element
-  # `element`, `pattern === element`:
+  # `element`, <code>pattern === element</code>:
   #
   #     [nil, false, 1.1].none?(Integer)      # => true
   #     %w[bar baz bat bam].none?(/m/)        # => false
@@ -1167,7 +1265,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Related: #one?, #all?, #any?.
   #
   def none?: () -> bool
-           | () { (Elem) -> boolish } -> bool
+           | (_Pattern) -> bool
+           | () { (E) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=enum.c
@@ -1187,7 +1286,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     [].one?               # => false
   #
   # With argument `pattern` and no block, returns whether for exactly one element
-  # `element`, `pattern === element`:
+  # `element`, <code>pattern === element</code>:
   #
   #     [nil, false, 0].one?(Integer)        # => true
   #     [nil, false, 0].one?(Numeric)        # => true
@@ -1210,7 +1309,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Related: #none?, #all?, #any?.
   #
   def one?: () -> bool
-          | () { (Elem) -> boolish } -> bool
+          | (_Pattern) -> bool
+          | () { (E) -> boolish } -> bool
 
   # <!--
   #   rdoc-file=enum.c
@@ -1239,8 +1339,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: Enumerable#group_by.
   #
-  def partition: () { (Elem) -> boolish } -> [ ::Array[Elem], ::Array[Elem] ]
-               | () -> ::Enumerator[Elem, [ ::Array[Elem], ::Array[Elem] ]]
+  def partition: () { (E) -> boolish } -> [ ::Array[E], ::Array[E] ]
+               | () -> ::Enumerator[E, [ ::Array[E], ::Array[E] ]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1259,8 +1359,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Related: #select.
   #
-  def reject: () { (Elem) -> boolish } -> ::Array[Elem]
-            | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def reject: () { (E) -> boolish } -> ::Array[E]
+            | () -> ::Enumerator[E, ::Array[E]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1286,8 +1386,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def reverse_each: () { (Elem arg0) -> untyped } -> void
-                  | () -> ::Enumerator[Elem]
+  def reverse_each: () { (E arg0) -> untyped } -> void
+                  | () -> ::Enumerator[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1297,7 +1397,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Returns an array containing the sorted elements of `self`. The ordering of
   # equal elements is indeterminate and may be unstable.
   #
-  # With no block given, the sort compares using the elements' own method `#<=>`:
+  # With no block given, the sort compares using the elements' own method
+  # <code>#<=></code>:
   #
   #     %w[b c a d].sort              # => ["a", "b", "c", "d"]
   #     {foo: 0, bar: 1, baz: 2}.sort # => [[:bar, 1], [:baz, 2], [:foo, 0]]
@@ -1305,9 +1406,9 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # With a block given, comparisons in the block determine the ordering. The block
   # is called with two elements `a` and `b`, and must return:
   #
-  # *   A negative integer if `a < b`.
-  # *   Zero if `a == b`.
-  # *   A positive integer if `a > b`.
+  # *   A negative integer if <code>a < b</code>.
+  # *   Zero if <code>a == b</code>.
+  # *   A positive integer if <code>a > b</code>.
   #
   # Examples:
   #
@@ -1319,8 +1420,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # See also #sort_by. It implements a Schwartzian transform which is useful when
   # key computation or comparison is expensive.
   #
-  def sort: () -> ::Array[Elem]
-          | () { (Elem arg0, Elem arg1) -> Integer } -> ::Array[Elem]
+  def sort: () -> ::Array[E]
+          | () { (E arg0, E arg1) -> Integer } -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1355,7 +1456,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #       b.report("Sort by") { a.sort_by { |a| a } }
   #     end
   #
-  # *produces:*
+  # <em>produces:</em>
   #
   #     user     system      total        real
   #     Sort        0.180000   0.000000   0.180000 (  0.175469)
@@ -1400,8 +1501,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   #     ary.sort_by { ... }.reverse!
   #
-  def sort_by: () { (Elem arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[Elem]
-             | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def sort_by: () { (E arg0) -> (Comparable | ::Array[untyped]) } -> ::Array[E]
+             | () -> ::Enumerator[E, ::Array[E]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1416,7 +1517,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     h = {foo: 0, bar: 1, baz: 2, bat: 3}
   #     h.take(2) # => [[:foo, 0], [:bar, 1]]
   #
-  def take: (Integer n) -> ::Array[Elem]
+  def take: (Integer n) -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1433,8 +1534,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def take_while: () { (Elem) -> boolish } -> ::Array[Elem]
-                | () -> ::Enumerator[Elem, ::Array[Elem]]
+  def take_while: () { (E) -> boolish } -> ::Array[E]
+                | () -> ::Enumerator[E, ::Array[E]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1456,7 +1557,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # block is not passed.
   #
   def to_h: () -> ::Hash[untyped, untyped]
-          | [T, U] () { (Elem) -> [ T, U ] } -> ::Hash[T, U]
+          | [T, U] () { (E) -> [ T, U ] } -> ::Hash[T, U]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1477,8 +1578,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def each_slice: (Integer n) { (::Array[Elem]) -> void } -> self
-                | (Integer n) -> ::Enumerator[::Array[Elem], self]
+  def each_slice: (Integer n) { (::Array[E]) -> void } -> self
+                | (Integer n) -> ::Enumerator[::Array[E], self]
 
   interface _NotFound[T]
     def call: () -> T
@@ -1506,10 +1607,10 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def find: () { (Elem) -> boolish } -> Elem?
-          | () -> ::Enumerator[Elem, Elem?]
-          | [T] (_NotFound[T] ifnone) { (Elem) -> boolish } -> (Elem | T)
-          | [T] (_NotFound[T] ifnone) -> ::Enumerator[Elem, Elem | T]
+  def find: () { (E) -> boolish } -> E?
+          | () -> ::Enumerator[E, E?]
+          | [T] (_NotFound[T] ifnone) { (E) -> boolish } -> (E | T)
+          | [T] (_NotFound[T] ifnone) -> ::Enumerator[E, E | T]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1530,8 +1631,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # Alias: #collect_concat.
   #
-  def flat_map: [U] () { (Elem) -> (Array[U] | U) } -> Array[U]
-              | () -> ::Enumerator[Elem, Array[untyped]]
+  def flat_map: [U] () { (E) -> (Array[U] | U) } -> Array[U]
+              | () -> ::Enumerator[E, Array[untyped]]
 
   # <!-- rdoc-file=enum.c -->
   # Returns an array of objects returned by the block.
@@ -1544,14 +1645,14 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def map: [U] () { (Elem arg0) -> U } -> ::Array[U]
-         | () -> ::Enumerator[Elem, ::Array[untyped]]
+  def map: [U] () { (E arg0) -> U } -> ::Array[U]
+         | () -> ::Enumerator[E, ::Array[untyped]]
 
   # <!--
   #   rdoc-file=enum.c
   #   - include?(object) -> true or false
   # -->
-  # Returns whether for any element `object == element`:
+  # Returns whether for any element <code>object == element</code>:
   #
   #     (1..4).include?(2)                       # => true
   #     (1..4).include?(5)                       # => false
@@ -1562,7 +1663,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     {foo: 0, bar: 1, baz: 2}.include?('foo') # => false
   #     {foo: 0, bar: 1, baz: 2}.include?(0)     # => false
   #
-  def member?: (Elem arg0) -> bool
+  def member?: (top arg0) -> bool
 
   # <!-- rdoc-file=enum.c -->
   # Returns the result of applying a reducer to an initial value and the first
@@ -1603,13 +1704,13 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     product #=> 24
   #
   # When this runs, the block is first called with `1` (the initial value) and `2`
-  # (the first element of the array). The block returns `1*2`, so on the next
-  # iteration the block is called with `2` (the previous result) and `3`. The
-  # block returns `6`, and is called one last time with `6` and `4`. The result of
-  # the block, `24` becomes the value returned by `inject`. This code returns the
-  # product of the elements in the enumerable.
+  # (the first element of the array). The block returns <code>1*2</code>, so on
+  # the next iteration the block is called with `2` (the previous result) and `3`.
+  # The block returns `6`, and is called one last time with `6` and `4`. The
+  # result of the block, `24` becomes the value returned by `inject`. This code
+  # returns the product of the elements in the enumerable.
   #
-  # **First Shortcut: Default Initial value**
+  # <strong>First Shortcut: Default Initial value</strong>
   #
   # In the case of the previous example, the initial value, `1`, wasn't really
   # necessary: the calculation of the product of a list of numbers is
@@ -1646,7 +1747,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Note that the last line of the block is just the word `counts`. This ensures
   # the return value of the block is the result that's being calculated.
   #
-  # **Second Shortcut: a Reducer function**
+  # <strong>Second Shortcut: a Reducer function</strong>
   #
   # A *reducer function* is a function that takes a partial result and the next
   # value, returning the next partial result. The block that is given to `inject`
@@ -1691,11 +1792,11 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     position = "nnneesw".chars.reduce(Turtle.new, :move)
   #     position  #=>> #<Turtle:0x00000001052f4698 @y=2, @x=1>
   #
-  # **Third Shortcut: Reducer With no Initial Value**
+  # <strong>Third Shortcut: Reducer With no Initial Value</strong>
   #
   # If your reducer returns a value that it can accept as a parameter, then you
-  # don't have to pass in an initial value. Here `:*` is the name of the *times*
-  # function:
+  # don't have to pass in an initial value. Here <code>:*</code> is the name of
+  # the *times* function:
   #
   #     product = [ 2, 3, 4 ].inject(:*)
   #     product # => 24
@@ -1720,7 +1821,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   #     (0..4).to_a # => [0, 1, 2, 3, 4]
   #
-  def to_a: () -> ::Array[Elem]
+  def to_a: () -> ::Array[E]
 
   # <!--
   #   rdoc-file=enumerator.c
@@ -1750,7 +1851,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     # show pythagorean triples less than 100
   #     p pythagorean_triples.take_while { |*, z| z < 100 }.force
   #
-  def lazy: () -> Enumerator::Lazy[Elem]
+  def lazy: () -> Enumerator::Lazy[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1758,7 +1859,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #   - uniq {|element| ... } -> array
   # -->
   # With no block, returns a new array containing only unique elements; the array
-  # has no two elements `e0` and `e1` such that `e0.eql?(e1)`:
+  # has no two elements `e0` and `e1` such that <code>e0.eql?(e1)</code>:
   #
   #     %w[a b c c b a a b c].uniq       # => ["a", "b", "c"]
   #     [0, 1, 2, 2, 1, 0, 0, 1, 2].uniq # => [0, 1, 2]
@@ -1771,8 +1872,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     a = %w[a b c d e e d c b a a b c d e]
   #     a.uniq {|c| c < 'c' }         # => ["a", "c"]
   #
-  def uniq: () -> ::Array[Elem]
-          | () { (Elem item) -> untyped } -> ::Array[Elem]
+  def uniq: () -> ::Array[E]
+          | () { (E item) -> untyped } -> ::Array[E]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1785,12 +1886,12 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     (1..100).sum(1)       # => 5051
   #     ('a'..'d').sum('foo') # => "fooabcd"
   #
-  # Generally, the sum is computed using methods `+` and `each`; for performance
-  # optimizations, those methods may not be used, and so any redefinition of those
-  # methods may not have effect here.
+  # Generally, the sum is computed using methods <code>+</code> and `each`; for
+  # performance optimizations, those methods may not be used, and so any
+  # redefinition of those methods may not have effect here.
   #
   # One such optimization: When possible, computes using Gauss's summation formula
-  # *n(n+1)/2*:
+  # <em>n(n+1)/2</em>:
   #
   #     100 * (100 + 1) / 2 # => 5050
   #
@@ -1803,10 +1904,10 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     h.sum {|key, value| value.odd? ? value : 0 } # => 9
   #     ('a'..'f').sum('x') {|c| c < 'd' ? c : '' }  # => "xabc"
   #
-  def sum: () -> (Elem | Integer)
-         | [T] () { (Elem arg0) -> T } -> (Integer | T)
-         | [T] (?T arg0) -> (Elem | T)
-         | [U] (?U arg0) { (Elem arg0) -> U } -> U
+  def sum: () -> (E | Integer)
+         | [T] () { (E arg0) -> T } -> (Integer | T)
+         | [T] (?T arg0) -> (E | T)
+         | [U] (?U arg0) { (E arg0) -> U } -> U
 
   # <!--
   #   rdoc-file=enum.c
@@ -1823,8 +1924,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # When no block given, returns an Enumerator.
   #
-  def filter_map: [U] () { (Elem elem) -> (nil | false | U) } -> ::Array[U]
-                | () -> ::Enumerator[Elem, ::Array[untyped]]
+  def filter_map: [U] () { (E elem) -> (nil | false | U) } -> ::Array[U]
+                | () -> ::Enumerator[E, ::Array[untyped]]
 
   # <!--
   #   rdoc-file=enumerator.c
@@ -1836,7 +1937,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     e = (1..3).chain([4, 5])
   #     e.to_a #=> [1, 2, 3, 4, 5]
   #
-  def chain: [Elem2] (*_Each[Elem2] enumerables) -> ::Enumerator::Chain[Elem | Elem2]
+  def chain: [Elem2] (*_Each[Elem2] enumerables) -> ::Enumerator::Chain[E | Elem2]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1882,7 +1983,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #         {foo: 'a', bar: 'b'}.tally(h) # => {[:foo, "a"]=>2, [:bar, "b"]=>2, [:foo, "c"]=>1, [:bar, "d"]=>1}
   #         {foo: 'c', bar: 'd'}.tally(h) # => {[:foo, "a"]=>2, [:bar, "b"]=>2, [:foo, "c"]=>2, [:bar, "d"]=>2}
   #
-  def tally: (?Hash[Elem, Integer] hash) -> ::Hash[Elem, Integer]
+  def tally: (?Hash[E, Integer] hash) -> ::Hash[E, Integer]
 
   # <!--
   #   rdoc-file=enum.c
@@ -1920,8 +2021,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def each_entry: () -> ::Enumerator[Elem, self]
-                | () { (Elem arg0) -> untyped } -> self
+  def each_entry: () -> ::Enumerator[E, self]
+                | () { (E arg0) -> untyped } -> self
 
   # <!--
   #   rdoc-file=enum.c
@@ -1929,8 +2030,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #   - zip(*other_enums) {|array| ... } -> nil
   # -->
   # With no block given, returns a new array `new_array` of size self.size whose
-  # elements are arrays. Each nested array `new_array[n]` is of size
-  # `other_enums.size+1`, and contains:
+  # elements are arrays. Each nested array <code>new_array[n]</code> is of size
+  # <code>other_enums.size+1</code>, and contains:
   #
   # *   The `n`-th element of self.
   # *   The `n`-th element of each of the `other_enums`.
@@ -1954,8 +2055,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #       #      [[:baz, 2], [:gaz, 5], [:haz, 8]]
   #       #    ]
   #
-  # If any enumerable in other_enums is smaller than self, fills to `self.size`
-  # with `nil`:
+  # If any enumerable in other_enums is smaller than self, fills to
+  # <code>self.size</code> with `nil`:
   #
   #     a = [:a0, :a1, :a2, :a3]
   #     b = [:b0, :b1, :b2]
@@ -1987,9 +2088,9 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     [:a2, :b2, :c2]
   #     [:a3, :b3, :c3]
   #
-  def zip: [Elem2] (_Each[Elem2] enum) -> Array[[ Elem, Elem2? ]]
+  def zip: [Elem2] (_Each[Elem2] enum) -> Array[[ E, Elem2? ]]
          | (_Each[untyped], *_Each[untyped]) -> Array[Array[untyped]]
-         | [Elem2] (_Each[Elem2]) { ([ Elem, Elem2? ]) -> void } -> nil
+         | [Elem2] (_Each[Elem2]) { ([ E, Elem2? ]) -> void } -> nil
          | (_Each[untyped], *_Each[untyped]) { (Array[untyped]) -> void } -> nil
 
   # <!--
@@ -2039,8 +2140,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     ["E", 8736]
   #     ["F", 6860]
   #
-  # You can use the special symbol `:_alone` to force an element into its own
-  # separate chuck:
+  # You can use the special symbol <code>:_alone</code> to force an element into
+  # its own separate chunk:
   #
   #     a = [0, 0, 1, 1]
   #     e = a.chunk{|i| i.even? ? :_alone : true }
@@ -2055,8 +2156,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #       }
   #     }
   #
-  # You can use the special symbol `:_separator` or `nil` to force an element to
-  # be ignored (not included in any chunk):
+  # You can use the special symbol <code>:_separator</code> or `nil` to force an
+  # element to be ignored (not included in any chunk):
   #
   #     a = [0, 0, -1, 1, 1]
   #     e = a.chunk{|i| i < 0 ? :_separator : true }
@@ -2096,8 +2197,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #       pp lines
   #     }
   #
-  def chunk: [U] () { (Elem elt) -> U } -> ::Enumerator[[ U, ::Array[Elem] ]]
-           | () -> ::Enumerator[Elem, ::Enumerator[[ untyped, ::Array[Elem] ]]]
+  def chunk: [U] () { (E elt) -> U } -> ::Enumerator[[ U, ::Array[E] ]]
+           | () -> ::Enumerator[E, ::Enumerator[[ untyped, ::Array[E] ]]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2146,7 +2247,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Enumerable#slice_when does the same, except splitting when the block returns
   # `true` instead of `false`.
   #
-  def chunk_while: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem]]
+  def chunk_while: () { (E elt_before, E elt_after) -> boolish } -> ::Enumerator[::Array[E]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2208,7 +2309,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Enumerable#chunk_while does the same, except splitting when the block returns
   # `false` instead of `true`.
   #
-  def slice_when: () { (Elem elt_before, Elem elt_after) -> boolish } -> ::Enumerator[::Array[Elem]]
+  def slice_when: () { (E elt_before, E elt_after) -> boolish } -> ::Enumerator[::Array[E]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2218,11 +2319,11 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # Creates an enumerator for each chunked elements. The ends of chunks are
   # defined by *pattern* and the block.
   #
-  # If *`pattern* === *elt`* returns `true` or the block returns `true` for the
-  # element, the element is end of a chunk.
+  # If <code>_pattern_ === _elt_</code> returns `true` or the block returns `true`
+  # for the element, the element is end of a chunk.
   #
-  # The `===` and *block* is called from the first element to the last element of
-  # *enum*.
+  # The <code>===</code> and *block* is called from the first element to the last
+  # element of *enum*.
   #
   # The result enumerator yields the chunked elements as an array. So `each`
   # method can be called as follows:
@@ -2243,8 +2344,8 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #     p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
   #     #=>["foo\n", "barbaz\n", "\n", "qux\n"]
   #
-  def slice_after: (untyped pattern) -> ::Enumerator[::Array[Elem]]
-                 | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem]]
+  def slice_after: (untyped pattern) -> ::Enumerator[::Array[E]]
+                 | () { (E elt) -> boolish } -> ::Enumerator[::Array[E]]
 
   # <!--
   #   rdoc-file=enum.c
@@ -2253,7 +2354,7 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   # -->
   # With argument `pattern`, returns an enumerator that uses the pattern to
   # partition elements into arrays ("slices"). An element begins a new slice if
-  # `element === pattern` (or if it is the first element).
+  # <code>element === pattern</code> (or if it is the first element).
   #
   #     a = %w[foo bar fop for baz fob fog bam foy]
   #     e = a.slice_before(/ba/) # => #<Enumerator: ...>
@@ -2400,6 +2501,6 @@ module Enumerable[unchecked out Elem] : _Each[Elem]
   #       }
   #     }
   #
-  def slice_before: (untyped pattern) -> ::Enumerator[::Array[Elem]]
-                  | () { (Elem elt) -> boolish } -> ::Enumerator[::Array[Elem]]
+  def slice_before: (untyped pattern) -> ::Enumerator[::Array[E]]
+                  | () { (E elt) -> boolish } -> ::Enumerator[::Array[E]]
 end