Question

Aggregates a sequence into a single value according to some accumulator function.

For an asynchronous sequence, instead of immediately returning a result (which it can't, obviously), this method returns an AsyncHandle whose onComplete method can be called to supply a callback to handle the final result once iteration has completed.

Signature

Sequence.reduce = function(aggregator, memo) { /*...*/ }

Sequence.reduce = function reduce(aggregator, memo) {
  if (arguments.length < 2) {
return this.tail().reduce(aggregator, this.head());
  }

  var eachResult = this.each(function(e, i) {
memo = aggregator(memo, e, i);
  });

  // TODO: Think of a way more efficient solution to this problem.
  if (eachResult instanceof AsyncHandle) {
return eachResult.then(function() { return memo; });
  }

  return memo;
}

Name	Type(s)	Description
aggregator	Function	The function through which to pass every element in the sequence. For every element, the function will be passed the total aggregated result thus far and the element itself, and should return a new aggregated result.
memo	*?	The starting value to use for the aggregated result (defaults to the first element in the sequence).
returns	*	The result of the aggregation, or, for asynchronous sequences, an AsyncHandle whose onComplete method accepts a callback to handle the final result.

Examples

function multiply(x, y) { return x * y; }

var numbers = [1, 2, 3, 4];

Lazy(numbers).reduce(multiply)    // => 24
Lazy(numbers).reduce(multiply, 5) // => 120