- * inject(symbol) -> object

- * inject(initial_operand, symbol) -> object

- * inject {|memo, operand| ... } -> object

- * inject(initial_operand) {|memo, operand| ... } -> object

- *

- * Returns an object formed from operands via either:

- * - A method named by +symbol+.

- * - A block to which each operand is passed.

- *

- * With method-name argument +symbol+,

- * combines operands using the method:

- *

- * # Sum, without initial_operand.

- * (1..4).inject(:+) # => 10

- * # Sum, with initial_operand.

- * (1..4).inject(10, :+) # => 20

- * With a block, passes each operand to the block:

- *

- * # Sum of squares, without initial_operand.

- * (1..4).inject {|sum, n| sum + n*n } # => 30

- * # Sum of squares, with initial_operand.

- * (1..4).inject(2) {|sum, n| sum + n*n } # => 32

- * <b>Operands</b>

- * If argument +initial_operand+ is not given,

- * the operands for +inject+ are simply the elements of +self+.

- * Example calls and their operands:

- * - <tt>(1..4).inject(:+)</tt>:: <tt>[1, 2, 3, 4]</tt>.

- * - <tt>(1...4).inject(:+)</tt>:: <tt>[1, 2, 3]</tt>.

- * - <tt>('a'..'d').inject(:+)</tt>:: <tt>['a', 'b', 'c', 'd']</tt>.

- * - <tt>('a'...'d').inject(:+)</tt>:: <tt>['a', 'b', 'c']</tt>.

- * Examples with first operand (which is <tt>self.first</tt>) of various types:

- * # Integer.

- * (1..4).inject(:+) # => 10

- * # Float.

- * [1.0, 2, 3, 4].inject(:+) # => 10.0

- * # Character.

- * ('a'..'d').inject(:+) # => "abcd"

- * # Complex.

- * [Complex(1, 2), 3, 4].inject(:+) # => (8+2i)

- * If argument +initial_operand+ is given,

- * the operands for +inject+ are that value plus the elements of +self+.

- * Example calls their operands:

- * - <tt>(1..4).inject(10, :+)</tt>:: <tt>[10, 1, 2, 3, 4]</tt>.

- * - <tt>(1...4).inject(10, :+)</tt>:: <tt>[10, 1, 2, 3]</tt>.

- * - <tt>('a'..'d').inject('e', :+)</tt>:: <tt>['e', 'a', 'b', 'c', 'd']</tt>.

- * - <tt>('a'...'d').inject('e', :+)</tt>:: <tt>['e', 'a', 'b', 'c']</tt>.

- * Examples with +initial_operand+ of various types:

- * # Integer.

- * (1..4).inject(2, :+) # => 12

- * # Float.

- * (1..4).inject(2.0, :+) # => 12.0

- * # String.

- * ('a'..'d').inject('foo', :+) # => "fooabcd"

- * # Array.

- * %w[a b c].inject(['x'], :push) # => ["x", "a", "b", "c"]

- * # Complex.

- * (1..4).inject(Complex(2, 2), :+) # => (12+2i)

- * <b>Combination by Given \Method</b>

- * If the method-name argument +symbol+ is given,

- * the operands are combined by that method:

- * - The first and second operands are combined.

- * - That result is combined with the third operand.

- * - That result is combined with the fourth operand.

- * - And so on.

- * The return value from +inject+ is the result of the last combination.

- * This call to +inject+ computes the sum of the operands:

- * (1..4).inject(:+) # => 10

- * Examples with various methods:

- * # Integer addition.

- * (1..4).inject(:+) # => 10

- * # Integer multiplication.

- * (1..4).inject(:*) # => 24

- * # Character range concatenation.

- * ('a'..'d').inject('', :+) # => "abcd"

- * # String array concatenation.

- * %w[foo bar baz].inject('', :+) # => "foobarbaz"

- * # Hash update.

- * h = [{foo: 0, bar: 1}, {baz: 2}, {bat: 3}].inject(:update)

- * h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}

- * # Hash conversion to nested arrays.

- * h = {foo: 0, bar: 1}.inject([], :push)

- * h # => [[:foo, 0], [:bar, 1]]

- * <b>Combination by Given Block</b>

- * If a block is given, the operands are passed to the block:

- * - The first call passes the first and second operands.

- * - The second call passes the result of the first call,

- * along with the third operand.

- * - The third call passes the result of the second call,

- * along with the fourth operand.

- * - And so on.

- * The return value from +inject+ is the return value from the last block call.

- *

- * This call to +inject+ gives a block

- * that writes the memo and element, and also sums the elements:

- * (1..4).inject do |memo, element|

- * p "Memo: #{memo}; element: #{element}"

- * memo + element

- * end # => 10

- * Output:

- * "Memo: 1; element: 2"

- * "Memo: 3; element: 3"

- * "Memo: 6; element: 4"