This is a multi-part message in MIME format.
--------------020105010408020309080009
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit

The attached patch fixes a cut-and-paste bug in the rdoc comment for 
Enumerable.none?

Also, enum.c has two different rdoc comments for Enumerable.inject and 
Enumerable.reduce, even though those two methods are synonyms.  Reading 
the comments it is hard to tell that the two methods actually do exactly 
the same thing.

In the attached patch I've merged and enhanced (I hope) the two comments 
into one and used both method names in the call-seq:, which seems to be 
the convention for other aliased methods.

	David

--------------020105010408020309080009
Content-Type: text/plain;
 nameatch"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
 filenameatch"

Index: enum.c
--- enum.c	(revision 13705)
+++ enum.c	(working copy)
@@ -362,67 +362,50 @@
 }
 
 /*
- *  Document-method: inject
  *  call-seq:
- *     enum.inject(sym)          obj
  *     enum.inject(sym, initial) obj
+ *     enum.inject(sym)          obj
  *     enum.inject(initial) {| memo, obj | block }  obj
  *     enum.inject          {| memo, obj | block }  obj
- *  
- *  Combines the elements of <i>enum</i> by applying the block to an
- *  accumulator value (<i>memo</i>) and each element in turn. At each
- *  step, <i>memo</i> is set to the value returned by the block. The
- *  first form lets you supply an initial value for <i>memo</i>. The
- *  second form uses the first element of the collection as a the
- *  initial value (and skips that element while iterating).
- *  See also <code>Enumerable#reduce</code>.
- *     
- *     # Sum some numbers
- *     (5..10).inject {|sum, n| sum + n }              #45
- *     # Multiply some numbers
- *     (5..10).inject(1) {|product, n| product * n }   #151200
- *     
- *     # find the longest word
- *     longest  w{ cat sheep bear }.inject do |memo,word|
- *        memo.length > word.length ? memo : word
- *     end
- *     longest                                         #"sheep"
- *     
- *     # find the length of the longest word
- *     longest  w{ cat sheep bear }.inject(0) do |memo,word|
- *        memo > ord.length ? memo : word.length
- *     end
- *     longest                                         #5
- *     
- */
-
-/*
- *  Document-method: reduce
- *  call-seq:
- *     enum.reduce(sym)          obj
+ *
  *     enum.reduce(sym, initial) obj
- *     enum.reduce          {| memo, obj | block }  obj
+ *     enum.reduce(sym)          obj
  *     enum.reduce(initial) {| memo, obj | block }  obj
+ *     enum.reduce          {| memo, obj | block }  obj
  *  
  *  Combines all elements of <i>enum</i> by applying a binary
- *  operation, specified by the block or metho-name symbol, for
- *  example, ary.reduce(:+) adds up all the elements.  If no block is
- *  specified, the first argument is a method (or operator) name that
- *  takes two arguments.  The second optional argument is the initial
- *  value.  If a block is specified, the first optional value is the
- *  initial value.
- *     
+ *  operation, specified by a block or a symbol that names a
+ *  method or operator.
+ *
+ *  If you specify a block, then for each element in <i>enum<i>
+ *  the block is passed an accumulator value (<i>memo</i>) and the element.
+ *  If you specify a symbol instead, then each element in the collection
+ *  will be passed to the named method of <i>memo</i>.
+ *  In either case, the result becomes the new value for <i>memo</i>. 
+ *  At the end of the iteration, the final value of <i>memo</i> is the
+ *  return value fo the method.
+ *
+ *  If you do not explicitly specify an <i>initial</i> value for <i>memo</i>,
+ *  then uses the first element of collection is used as the initial value
+ *  of <i>memo</i>.
+ *
+ *  Examples:   
+ *
  *     # Sum some numbers
  *     (5..10).reduce(:+)                            #45
- *     # Same using a block
- *     (5..10).reduce {|sum, n| sum + n }            #45
+ *     # Same using a block and inject
+ *     (5..10).inject {|sum, n| sum + n }            #45
  *     # Multiply some numbers
  *     (5..10).reduce(:*, 1)                         #151200
  *     # Same using a block
- *     (5..10).reduce(1) {|product, n| product * n } #151200
+ *     (5..10).inject(1) {|product, n| product * n } #151200
+ *     # find the longest word
+ *     longest  w{ cat sheep bear }.inject do |memo,word|
+ *        memo.length > word.length ? memo : word
+ *     end
+ *     longest                                       #"sheep"
  *     
  */
-
 static VALUE
 enum_inject(int argc, VALUE *argv, VALUE obj)
 {
@@ -855,7 +838,7 @@
  *  Passes each element of the collection to the given block. The method
  *  returns <code>true</code> if the block returns <code>true</code>
  *  exactly once. If the block is not given, <code>one?</code> will return
- *  <code>true</code> only if exactly one of the collection members are
+ *  <code>true</code> only if exactly one of the collection members is
  *  true.
  *     
  *     %w{ant bear cat}.one? {|word| word.length 4}   #true
@@ -897,15 +880,15 @@
  *  
  *  Passes each element of the collection to the given block. The method
  *  returns <code>true</code> if the block never returns <code>true</code>
- *  for all elements. If the block is not given, <code>one?</code> will return
- *  <code>true</code> only if any of the collection members is true.
+ *  for all elements. If the block is not given, <code>none?</code> will return
+ *  <code>true</code> only if none of the collection members is true.
  *     
- *     %w{ant bear cat}.one? {|word| word.length 4}   #true
- *     %w{ant bear cat}.one? {|word| word.length > }   #false
- *     [ nil, true, 99 ].one?                            #true
- *     
+ *     %w{ant bear cat}.none? {|word| word.length 5}  #true
+ *     %w{ant bear cat}.none? {|word| word.length > }  #false
+ *     [].none?                                          #true
+ *     [nil].none?                                       #true
+ *     [nil,false].none?                                 #true
  */
-
 static VALUE
 enum_none(VALUE obj)
 {

--------------020105010408020309080009--