HORIZON PROJECT

var arrayReduce = require('./_arrayReduce'),

    baseEach = require('./_baseEach'),

    baseIteratee = require('./_baseIteratee'),

    baseReduce = require('./_baseReduce'),

    isArray = require('./isArray');

/**

 * Reduces `collection` to a value which is the accumulated result of running

 * each element in `collection` thru `iteratee`, where each successive

 * invocation is supplied the return value of the previous. If `accumulator`

 * is not given, the first element of `collection` is used as the initial

 * value. The iteratee is invoked with four arguments:

 * (accumulator, value, index|key, collection).

 *

 * Many lodash methods are guarded to work as iteratees for methods like

 * `_.reduce`, `_.reduceRight`, and `_.transform`.

 *

 * The guarded methods are:

 * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,

 * and `sortBy`

 *

 * @static

 * @memberOf _

 * @since 0.1.0

 * @category Collection

 * @param {Array|Object} collection The collection to iterate over.

 * @param {Function} [iteratee=_.identity] The function invoked per iteration.

 * @param {*} [accumulator] The initial value.

 * @returns {*} Returns the accumulated value.

 * @see _.reduceRight

 * @example

 *

 * _.reduce([1, 2], function(sum, n) {

 *   return sum + n;

 * }, 0);

 * // => 3

 *

 * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {

 *   (result[value] || (result[value] = [])).push(key);

 *   return result;

 * }, {});

 * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)

 */

function reduce(collection, iteratee, accumulator) {

  var func = isArray(collection) ? arrayReduce : baseReduce,

      initAccum = arguments.length < 3;

  return func(collection, baseIteratee(iteratee, 4), accumulator, initAccum, baseEach);

}

module.exports = reduce;