On Dec 27, 2010, at 09:25 , jzakiya wrote:

> On Dec 27, 4:23 am, Ryan Davis <ryand-r... / zenspider.com> wrote:
>> On Dec 27, 2010, at 00:55 , Skye Shaw!@#$ wrote:
>> 
>>>> Is this a bug, or is this the expected operation?
>> 
>>> Expected, though it's an odd way to require libs. Use %/ap
>>> mathn .../.each { |lib| require lib }
>> 
>> Even better, use simple code for simple problems:
>> 
>> require "ap"
>> require "mathn"
>> # ...etc...
>> 
>> It REALLY isn't cleaning anything up to use enumeration there.
> 
> I was wondering why these are equivalent:
> 
> a=(1..100).inject :+
> b=(1..100).inject 0, :+
> 
> but these aren't
> 
> %w/lib1 lib2 lib3/.inject :require
> %w/lib1 lib2 lib3/.inject 0, :require

1887 % ri Enumerable.inject
= Enumerable.inject

(from ruby core)
------------------------------------------------------------------------------
  enum.inject(initial, sym) => obj
  enum.inject(sym)          => obj
  enum.inject(initial) {| memo, obj | block }  => obj
  enum.inject          {| memo, obj | block }  => obj

------------------------------------------------------------------------------

  enum.reduce(initial, sym) => obj
  enum.reduce(sym)          => obj
  enum.reduce(initial) {| memo, obj | block }  => obj
  enum.reduce          {| memo, obj | block }  => obj

Combines all elements of enum by applying a binary operation,
specified by a block or a symbol that names a method or operator.

If you specify a block, then for each element in enum<i>
the block is passed an
accumulator value
(<i>memo) and the element. If you specify a symbol instead,
then each element in the collection will be passed to the named method of
memo. In either case, the result becomes the new value for
memo. At the end of the iteration, the final value of memo is
the return value fo the method.

If you do not explicitly specify an initial value for
memo, then uses the first element of collection is used as the initial
value of memo.

Examples:

  # Sum some numbers
  (5..10).reduce(:+)                            #=> 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).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"