rdx 0.9.0.pre

data/examples/ruby-2.0.0-p0/install/core/diffs/enum.c.diff

@@ -0,0 +1,281 @@
+--- core/orig/enum.c	2015-06-11 07:51:43 +0000
++++ core/patched/enum.c	2015-06-25 17:35:23 +0000
+@@ -834,7 +834,9 @@
+  *  call-seq:
+  *     enum.sort_by { |obj| block }   -> array
+  *     enum.sort_by                   -> an_enumerator
+- *
++ * 
++ *  :rdx: in_tmpdir!
++ * 
+  *  Sorts <i>enum</i> using a set of keys generated by mapping the
+  *  values in <i>enum</i> through the given block.
+  *
+@@ -848,6 +850,7 @@
+  *  mapped value. This makes <code>sort_by</code> fairly expensive when
+  *  the keysets are simple.
+  *
++ *  :rdx: indicative_numbers
+  *     require 'benchmark'
+  *
+  *     a = (1..100000).map { rand(100000) }
+@@ -857,15 +860,23 @@
+  *       b.report("Sort by") { a.sort_by { |a| a } }
+  *     end
+  *
+- *  <em>produces:</em>
++ *  <em>On my machine produces:</em>
++ *  :rdx: output
+  *
+- *     user     system      total        real
++ *                     user     system      total        real
+  *     Sort        0.180000   0.000000   0.180000 (  0.175469)
+  *     Sort by     1.980000   0.040000   2.020000 (  2.013586)
+  *
+  *  However, consider the case where comparing the keys is a non-trivial
+  *  operation. The following code sorts some files on modification time
+  *  using the basic <code>sort</code> method.
++ * 
++ *-- rdx
++ *     %w[ mon tues wed thurs ].each_with_index do |fname,i|
++ *       File.write fname, 'something'
++ *       File.utime i, i, fname
++ *     end
++ *++
+  *
+  *     files = Dir["*"]
+  *     sorted = files.sort { |a, b| File.new(a).mtime <=> File.new(b).mtime }
+@@ -1693,7 +1704,7 @@
+  *
+  *      (1..3).reverse_each { |v| p v }
+  *
+- *    produces:
++ *  produces:
+  *
+  *      3
+  *      2
+@@ -1805,7 +1816,9 @@
+  *  block is given, returns an enumerator.
+  *
+  *      (1..10).each_slice(3) { |a| p a }
+- *      # outputs below
++ *      
++ *  produces:
++ * 
+  *      [1, 2, 3]
+  *      [4, 5, 6]
+  *      [7, 8, 9]
+@@ -1873,7 +1886,9 @@
+  *
+  *  e.g.:
+  *      (1..10).each_cons(3) { |a| p a }
+- *      # outputs below
++ *      
++ *  produces:
++ * 
+  *      [1, 2, 3]
+  *      [2, 3, 4]
+  *      [3, 4, 5]
+@@ -2272,8 +2287,10 @@
+  *  If no block is given, an enumerator is returned instead.
+  *
+  *     a = ["a", "b", "c"]
+- *     a.cycle { |x| puts x }  # print, a, b, c, a, b, c,.. forever.
+- *     a.cycle(2) { |x| puts x }  # print, a, b, c, a, b, c.
++ *  :rdx: off
++ *     a.cycle { |x| print x }     # prints abcabcabc... forever
++ *  :rdx: on
++ *     a.cycle(2) { |x| print x }  # prints abcabc
+  *
+  */
+ 
+@@ -2405,26 +2422,35 @@
+  *    [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk { |n|
+  *      n.even?
+  *    }.each { |even, ary|
+- *      p [even, ary]
++ *      print [even, ary], "\n"
+  *    }
+- *    #=> [false, [3, 1]]
+- *    #   [true, [4]]
+- *    #   [false, [1, 5, 9]]
+- *    #   [true, [2, 6]]
+- *    #   [false, [5, 3, 5]]
++ * 
++ *  produces:
++ * 
++ *    [false, [3, 1]]
++ *    [true, [4]]
++ *    [false, [1, 5, 9]]
++ *    [true, [2, 6]]
++ *    [false, [5, 3, 5]]
+  *
+  *  This method is especially useful for sorted series of elements.
+  *  The following example counts words for each initial letter.
+- *
++ *  :rdx: off
++ * 
+  *    open("/usr/share/dict/words", "r:iso-8859-1") { |f|
+- *      f.chunk { |line| line.ord }.each { |ch, lines| p [ch.chr, lines.length] }
++ *      f.chunk { |line| line.ord }.each { |ch, lines| print [ch.chr, lines.length], "\n" }
+  *    }
+- *    #=> ["\n", 1]
+- *    #   ["A", 1327]
+- *    #   ["B", 1372]
+- *    #   ["C", 1507]
+- *    #   ["D", 791]
+- *    #   ...
++ * 
++ *  on my machine produces:
++ * 
++ *    ["\n", 1]
++ *    ["A", 1327]
++ *    ["B", 1372]
++ *    ["C", 1507]
++ *    ["D", 791]
++ *    ...
++ *  
++ *  :rdx: on
+  *
+  *  The following key values have special meaning:
+  *  - +nil+ and +:_separator+ specifies that the elements should be dropped.
+@@ -2432,33 +2458,39 @@
+  *
+  *  Any other symbols that begin with an underscore will raise an error:
+  *
+- *    items.chunk { |item| :_underscore }
+- *    #=> RuntimeError: symbol begins with an underscore is reserved
++ *    enum = [1,2,3].chunk { |item| :_underscore }
++ *    enum.each{}
++ *    # raises RuntimeError: symbol begins with an underscore is reserved
+  *
+  *  +nil+ and +:_separator+ can be used to ignore some elements.
+  *
+  *  For example, the sequence of hyphens in svn log can be eliminated as follows:
+  *
++ *  :rdx: off
++ * 
+  *    sep = "-"*72 + "\n"
+  *    IO.popen("svn log README") { |f|
+  *      f.chunk { |line|
+  *        line != sep || nil
+  *      }.each { |_, lines|
+- *        pp lines
++ *        puts lines
+  *      }
+  *    }
+- *    #=> ["r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines\n",
+- *    #    "\n",
+- *    #    "* README, README.ja: Update the portability section.\n",
+- *    #    "\n"]
+- *    #   ["r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines\n",
+- *    #    "\n",
+- *    #    "* README, README.ja: Add a note about default C flags.\n",
+- *    #    "\n"]
+- *    #   ...
++ * 
++ *  on my machine produces:
++ * 
++ *    r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines
++ *    
++ *    * README, README.ja: Update the portability section.
++ *    
++ *    r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines
++ *    
++ *    * README, README.ja: Add a note about default C flags
++ *    
++ *    ...
+  *
+  *  Paragraphs separated by empty lines can be parsed as follows:
+- *
++ * 
+  *    File.foreach("README").chunk { |line|
+  *      /\A\s*\z/ !~ line || nil
+  *    }.each { |_, lines|
+@@ -2582,6 +2614,7 @@
+  *  The result enumerator yields the chunked elements as an array.
+  *  So +each+ method can be called as follows:
+  *
++ *  :rdx: off -
+  *    enum.slice_before(pattern).each { |ary| ... }
+  *    enum.slice_before { |elt| bool }.each { |ary| ... }
+  *    enum.slice_before(initial_state) { |elt, state| bool }.each { |ary| ... }
+@@ -2591,6 +2624,8 @@
+  *
+  *  For example, iteration over ChangeLog entries can be implemented as
+  *  follows:
++ *  
++ *  :rdx: off
+  *
+  *    # iterate over ChangeLog entries.
+  *    open("ChangeLog") { |f|
+@@ -2602,27 +2637,31 @@
+  *      f.slice_before { |line| /\A\S/ === line }.each { |e| pp e }
+  *    }
+  *
+- *
+  *  "svn proplist -R" produces multiline output for each file.
+  *  They can be chunked as follows:
+  *
+  *    IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) { |f|
+- *      f.lines.slice_before(/\AProp/).each { |lines| p lines }
++ *      f.lines.slice_before(/\AProp/).each { |lines| print lines, "\n" }
+  *    }
+- *    #=> ["Properties on '.':\n", "  svn:ignore\n", "  svk:merge\n"]
+- *    #   ["Properties on 'goruby.c':\n", "  svn:eol-style\n"]
+- *    #   ["Properties on 'complex.c':\n", "  svn:mime-type\n", "  svn:eol-style\n"]
+- *    #   ["Properties on 'regparse.c':\n", "  svn:eol-style\n"]
+- *    #   ...
++ * 
++ *  on my machine produces:
++ * 
++ *    ["Properties on '.':\n", "  svn:ignore\n", "  svk:merge\n"]
++ *    ["Properties on 'goruby.c':\n", "  svn:eol-style\n"]
++ *    ["Properties on 'complex.c':\n", "  svn:mime-type\n", "  svn:eol-style\n"]
++ *    ["Properties on 'regparse.c':\n", "  svn:eol-style\n"]
++ *    ...
+  *
+  *  If the block needs to maintain state over multiple elements,
+  *  local variables can be used.
+  *  For example, three or more consecutive increasing numbers can be squashed
+  *  as follows:
++ * 
++ *  :rdx: on
+  *
+  *    a = [0, 2, 3, 4, 6, 7, 9]
+  *    prev = a[0]
+- *    p a.slice_before { |e|
++ *    a.slice_before { |e|
+  *      prev, prev2 = e, prev
+  *      prev2 + 1 != e
+  *    }.map { |es|
+@@ -2658,18 +2697,21 @@
+  *    puts "-"*10
+  *    enum.each { |ws| puts ws.join(" ") }
+  *    puts "-"*10
+- *    #=> ----------
+- *    #   1 2 3 4 5
+- *    #   6 7 8 9 10
+- *    #   11 12 13
+- *    #   14 15 16
+- *    #   17 18 19
+- *    #   20
+- *    #   ----------
++ *  produces:
++ *    ----------
++ *    1 2 3 4 5
++ *    6 7 8 9 10
++ *    11 12 13
++ *    14 15 16
++ *    17 18 19
++ *    20
++ *    ----------
+  *
+  *  mbox contains series of mails which start with Unix From line.
+  *  So each mail can be extracted by slice before Unix From line.
+  *
++ *  :rdx: off
++ * 
+  *    # parse mbox
+  *    open("mbox") { |f|
+  *      f.slice_before { |line|

data/examples/ruby-2.0.0-p0/install/core/diffs/enumerator.c.diff

@@ -0,0 +1,479 @@
+--- core/orig/enumerator.c	2015-06-11 07:51:44 +0000
++++ core/patched/enumerator.c	2015-06-20 08:06:24 +0000
+@@ -26,51 +26,80 @@
+  * - Kernel#enum_for
+  * - Enumerator.new
+  *
+- * Most methods have two forms: a block form where the contents
+- * are evaluated for each item in the enumeration, and a non-block form
+- * which returns a new Enumerator wrapping the iteration.
++ * Most methods have two forms:
++ * * a block form where the contents are evaluated
++ *   for each item in the enumeration:
+  *
+- *   enumerator = %w(one two three).each
+- *   puts enumerator.class # => Enumerator
++ *     enumerator = %w(one two three).each
++ *     enumerator.class # => Enumerator
+  *
+- *   enumerator.each_with_object("foo") do |item, obj|
+- *     puts "#{obj}: #{item}"
+- *   end
+- *
+- *   # foo: one
+- *   # foo: two
+- *   # foo: three
++ *     enumerator.each_with_object("foo") do |item, obj|
++ *       puts "#{obj}: #{item}"
++ *     end
++ * 
++ *   produces:
+  *
+- *   enum_with_obj = enumerator.each_with_object("foo")
+- *   puts enum_with_obj.class # => Enumerator
++ *     foo: one
++ *     foo: two
++ *     foo: three
++ *
++ * * a non-block form which returns a new Enumerator
++ *   wrapping the iteration:
++ * 
++ *     enum_with_obj = enumerator.each_with_object("foo")
++ *     enum_with_obj.class # => Enumerator
+  *
+- *   enum_with_obj.each do |item, obj|
+- *     puts "#{obj}: #{item}"
+- *   end
++ *     enum_with_obj.each do |item, obj|
++ *       puts "#{obj}: #{item}"
++ *     end
+  *
+- *   # foo: one
+- *   # foo: two
+- *   # foo: three
++ *   produces:
++ * 
++ *     foo: one
++ *     foo: two
++ *     foo: three
+  *
+  * This allows you to chain Enumerators together.  For example, you
+  * can map a list's elements to strings containing the index
+  * and the element as a string via:
+  *
+- *   puts %w[foo bar baz].map.with_index { |w, i| "#{i}:#{w}" }
++ *   %w[foo bar baz].map.with_index { |w, i| "#{i}:#{w}" }
+  *   # => ["0:foo", "1:bar", "2:baz"]
+  *
+  * An Enumerator can also be used as an external iterator.
+  * For example, Enumerator#next returns the next value of the iterator
+  * or raises StopIteration if the Enumerator is at the end.
+  *
+- *   e = [1,2,3].each   # returns an enumerator object.
+- *   puts e.next   # => 1
+- *   puts e.next   # => 2
+- *   puts e.next   # => 3
+- *   puts e.next   # raises StopIteration
++ *   e = [1,2,3].each   # > #<Enumerator: [1, 2, 3]:each>
++ *   e.next   # => 1
++ *   e.next   # => 2
++ *   e.next   # => 3
++ *   e.next   # raises StopIteration
+  *
+  * You can use this to implement an internal iterator as follows:
+  *
++ *   o = Object.new
++ *
++ *   def o.each
++ *     yield
++ *     yield(1)
++ *     yield(1, 2)
++ *     3
++ *   end
++ *
++ * Use o.each as an internal iterator directly:
++ * 
++ *   o.each {|*x| print x, "\n" } #=> 3
++ *   # puts would have expanded the arrays
++ * 
++ * produces:
++ * 
++ *   []
++ *   [1]
++ *   [1, 2]
++ * 
++ * Or convert an internal iterator to an external one:
++ *
+  *   def ext_each(e)
+  *     while true
+  *       begin
+@@ -82,24 +111,16 @@
+  *       e.feed y
+  *     end
+  *   end
+- *
+- *   o = Object.new
+- *
+- *   def o.each
+- *     puts yield
+- *     puts yield(1)
+- *     puts yield(1, 2)
+- *     3
+- *   end
+- *
+- *   # use o.each as an internal iterator directly.
+- *   puts o.each {|*x| puts x; [:b, *x] }
+- *   # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
+- *
++ * 
+  *   # convert o.each to an external iterator for
+  *   # implementing an internal iterator.
+- *   puts ext_each(o.to_enum) {|*x| puts x; [:b, *x] }
+- *   # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
++ *   ext_each(o.to_enum) {|*x| print x, "\n" } #=> 3
++ * 
++ * produces:
++ * 
++ *   []
++ *   [1]
++ *   [1, 2]
+  *
+  */
+ VALUE rb_cEnumerator;
+@@ -197,23 +218,34 @@
+  *
+  * === Examples
+  *
++ * Iterating over a string:
+  *   str = "xyz"
+  *
+  *   enum = str.enum_for(:each_byte)
+  *   enum.each { |b| puts b }
+- *   # => 120
+- *   # => 121
+- *   # => 122
+- *
+- *   # protect an array from being modified by some_method
++ * produces:
++ *   120
++ *   121
++ *   122
++ *
++ * Protect an array from being modified (an enumerator doesn't respond to destructive methods):
++ *   def some_method ary
++ *     ary.each{ |x| } # do something...
++ *     ary.clear
++ *   end
+  *   a = [1, 2, 3]
+- *   some_method(a.to_enum)
++ *   some_method(a)
++ *   a #=> []
++ *   e = [1, 2, 3].to_enum
++ *   some_method(e) # raises NoMethodError
+  *
+  * It is typical to call to_enum when defining methods for
+  * a generic Enumerable, in case no block is passed.
+  *
+  * Here is such an example, with parameter passing and a sizing block:
+  *
++ * :rdx: toplevel
++ * 
+  *   module Enumerable
+  *     # a generic method to repeat the values of any enumerable
+  *     def repeat(n)
+@@ -230,10 +262,11 @@
+  *     end
+  *   end
+  *
+- *   %i[hello world].repeat(2) { |w| puts w }
+- *     # => Prints 'hello', 'hello', 'world', 'world'
++ *   %i[hello world].repeat(2) { |w| print w, ' ' }
++ *   # Prints: hello hello world world
++ * 
+  *   enum = (1..14).repeat(3)
+- *     # => returns an Enumerator when called without a block
++ *     # returns an Enumerator when called without a block
+  *   enum.first(4) # => [1, 1, 1, 2]
+  *   enum.size # => 42
+  */
+@@ -310,7 +343,7 @@
+  *     end
+  *   end
+  *
+- *   p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
++ *   fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+  *
+  * The optional parameter can be used to specify how to calculate the size
+  * in a lazy fashion (see Enumerator#size). It can either be a value or
+@@ -325,7 +358,19 @@
+  *   e = Enumerator.new(ObjectSpace, :each_object)
+  *       #-> ObjectSpace.enum_for(:each_object)
+  *
+- *   e.select { |obj| obj.is_a?(Class) }  #=> array of all classes
++ * produces on stderr:
++ * :rdx: stderr
++ * 
++ *   warning: Enumerator.new without a block is deprecated; use Object#to_enum
++ * 
++ * However it's still usable:
++ * 
++ *   e.select { |obj| obj.is_a?(Class) }
++ *     # -> [
++ *     #      Class, Module, Object, Numeric, String,
++ *     #      # ... all other classes
++ *     #    ]
++ * 
+  *
+  */
+ static VALUE
+@@ -545,10 +590,12 @@
+  *   to_three_with_string.each do |x,string|
+  *     puts "#{string}: #{x}"
+  *   end
++ * 
++ * produces:
+  *
+- *   # => foo:0
+- *   # => foo:1
+- *   # => foo:2
++ *   foo: 0
++ *   foo: 1
++ *   foo: 2
+  */
+ static VALUE
+ enumerator_with_object(VALUE obj, VALUE memo)
+@@ -641,25 +688,29 @@
+  *     yield nil
+  *     yield [1, 2]
+  *   end
+- *   e = o.to_enum
+- *   p e.next_values
+- *   p e.next_values
+- *   p e.next_values
+- *   p e.next_values
+- *   p e.next_values
+- *   e = o.to_enum
+- *   p e.next
+- *   p e.next
+- *   p e.next
+- *   p e.next
+- *   p e.next
+- *
+- *   ## yield args       next_values      next
+- *   #  yield            []               nil
+- *   #  yield 1          [1]              1
+- *   #  yield 1, 2       [1, 2]           [1, 2]
+- *   #  yield nil        [nil]            nil
+- *   #  yield [1, 2]     [[1, 2]]         [1, 2]
++ * 
++ *   e1 = o.to_enum
++ *   e2 = o.to_enum
++ * 
++ *   # yield
++ *   e1.next_values   #=> []
++ *   e2.next          #=> nil
++ * 
++ *   # yield 1
++ *   e1.next_values   #=> [1]
++ *   e2.next          #=> 1
++ * 
++ *   # yield 1, 2
++ *   e1.next_values   #=> [1, 2]
++ *   e2.next          #=> [1, 2]
++ * 
++ *   # yield nil
++ *   e1.next_values   #=> [nil]
++ *   e2.next          #=> nil
++ * 
++ *   # yield [1, 2]
++ *   e1.next_values   #=> [[1, 2]]
++ *   e2.next          #=> [1, 2]
+  *
+  * Note that +next_values+ does not affect other non-external enumeration
+  * methods unless underlying iteration method itself has side-effect, e.g.
+@@ -713,10 +764,10 @@
+  *
+  *   a = [1,2,3]
+  *   e = a.to_enum
+- *   p e.next   #=> 1
+- *   p e.next   #=> 2
+- *   p e.next   #=> 3
+- *   p e.next   #raises StopIteration
++ *   e.next   #=> 1
++ *   e.next   #=> 2
++ *   e.next   #=> 3
++ *   e.next   #raises StopIteration
+  *
+  * Note that enumeration sequence by +next+ does not affect other non-external
+  * enumeration methods, unless the underlying iteration methods itself has
+@@ -759,14 +810,14 @@
+  *     yield 1, 2
+  *   end
+  *   e = o.to_enum
+- *   p e.peek_values    #=> []
++ *   e.peek_values    #=> []
+  *   e.next
+- *   p e.peek_values    #=> [1]
+- *   p e.peek_values    #=> [1]
++ *   e.peek_values    #=> [1]
++ *   e.peek_values    #=> [1]
+  *   e.next
+- *   p e.peek_values    #=> [1, 2]
++ *   e.peek_values    #=> [1, 2]
+  *   e.next
+- *   p e.peek_values    # raises StopIteration
++ *   e.peek_values    # raises StopIteration
+  *
+  */
+ 
+@@ -788,13 +839,13 @@
+  *
+  *   a = [1,2,3]
+  *   e = a.to_enum
+- *   p e.next   #=> 1
+- *   p e.peek   #=> 2
+- *   p e.peek   #=> 2
+- *   p e.peek   #=> 2
+- *   p e.next   #=> 2
+- *   p e.next   #=> 3
+- *   p e.next   #raises StopIteration
++ *   e.next   #=> 1
++ *   e.peek   #=> 2
++ *   e.peek   #=> 2
++ *   e.peek   #=> 2
++ *   e.next   #=> 2
++ *   e.next   #=> 3
++ *   e.next   #raises StopIteration
+  *
+  */
+ 
+@@ -815,22 +866,27 @@
+  *
+  * This value is cleared after being yielded.
+  *
++ * :rdx: no_warnings eval
+  *   o = Object.new
+  *   def o.each
+- *     x = yield         # (2) blocks
+- *     p x               # (5) => "foo"
+- *     x = yield         # (6) blocks
+- *     p x               # (8) => nil
+- *     x = yield         # (9) blocks
++ *     x = yield         # (2)  blocks
++ *     p x               # (5)  x == "foo"
++ *     x = yield         # (6)  blocks
++ *     p x               # (9)  x == nil
++ *     x = yield         # (10) blocks
+  *     p x               # not reached w/o another e.next
+  *   end
+- *
+  *   e = o.to_enum
++ * 
+  *   e.next              # (1)
+  *   e.feed "foo"        # (3)
+- *   e.next              # (4)
+- *   e.next              # (7)
+- *                       # (10)
++ *                       # (4)  next call
++ *   e.next              # prints: "foo"
++ *                       # (7)  next returns
++ *                       # (8)  next call
++ *   e.next              # prints: nil
++ *                       # (11) next return
++ * 
+  */
+ 
+ static VALUE
+@@ -964,7 +1020,7 @@
+  * Returns the size of the enumerator, or +nil+ if it can't be calculated lazily.
+  *
+  *   (1..100).to_a.permutation(4).size # => 94109400
+- *   loop.size # => Float::INFINITY
++ *   loop.size # > Infinity
+  *   (1..100).drop_while.size # => nil
+  */
+ 
+@@ -1354,6 +1410,7 @@
+  * === Example
+  *
+  * The following program finds pythagorean triples:
++ * :rdx: discard_output
+  *
+  *   def pythagorean_triples
+  *     (1..Float::INFINITY).lazy.flat_map {|z|
+@@ -1366,6 +1423,7 @@
+  *       }
+  *     }
+  *   end
++ * 
+  *   # show first ten pythagorean triples
+  *   p pythagorean_triples.take(10).force # take is lazy, so force is needed
+  *   p pythagorean_triples.first(10)      # first is eager
+@@ -1400,12 +1458,31 @@
+  * naturally remain lazy if called from a lazy enumerator.
+  *
+  * For example, continuing from the example in Kernel#to_enum:
+- *
++ * 
+  *   # See Kernel#to_enum for the definition of repeat
++ *-- rdx
++ *   module ::Enumerable
++ *     # a generic method to repeat the values of any enumerable
++ *     def repeat(n)
++ *       raise ArgumentError, "#{n} is negative!" if n < 0
++ *       unless block_given?
++ *         return to_enum(__method__, n) do # __method__ is :repeat here
++ *           sz = size     # Call size and multiply by n...
++ *           sz * n if sz  # but return nil if size itself is nil
++ *         end
++ *       end
++ *       each do |*val|
++ *         n.times { yield *val }
++ *       end
++ *     end
++ *   end
++ *++
+  *   r = 1..Float::INFINITY
+  *   r.repeat(2).first(5) # => [1, 1, 2, 2, 3]
+  *   r.repeat(2).class # => Enumerator
+- *   r.repeat(2).map{|n| n ** 2}.first(5) # => endless loop!
++ * :rdx: off
++ *   r.repeat(2).map{|n| n ** 2}.first(5) # endless loop!
++ * :rdx:
+  *   # works naturally on lazy enumerator:
+  *   r.lazy.repeat(2).class # => Enumerator::Lazy
+  *   r.lazy.repeat(2).map{|n| n ** 2}.first(5) # => [1, 1, 4, 4, 9]
+@@ -1511,9 +1588,9 @@
+  *  A value <i>x</i> returned by <i>block</i> is decomposed if either of
+  *  the following conditions is true:
+  *
+- *    a) <i>x</i> responds to both each and force, which means that
+- *       <i>x</i> is a lazy enumerator.
+- *    b) <i>x</i> is an array or responds to to_ary.
++ *  * <i>x</i> responds to both each and force, which means that
++ *    <i>x</i> is a lazy enumerator.
++ *  * <i>x</i> is an array or responds to to_ary.
+  *
+  *  Otherwise, <i>x</i> is contained as-is in the return value.
+  *
+@@ -1888,15 +1965,15 @@
+  *
+  *   e = o.to_enum
+  *
+- *   puts e.next                   #=> 1
+- *   puts e.next                   #=> 2
+- *   puts e.next                   #=> 3
++ *   e.next                   #=> 1
++ *   e.next                   #=> 2
++ *   e.next                   #=> 3
+  *
+  *   begin
+  *     e.next
+  *   rescue StopIteration => ex
+- *     puts ex.result              #=> 100
+- *   end
++ *     ex.result
++ *   end                      #=> 100
+  *
+  */
+