text: var _curry3 = require('./internal/_curry3');
  var _isTransformer = require('./internal/_isTransformer');
  var _reduce = require('./internal/_reduce');
  var _stepCat = require('./internal/_stepCat');
  
  
  /**
   * Transforms the items of the list with the transducer and appends the transformed items to
   * the accumulator using an appropriate iterator function based on the accumulator type.
   *
   * The accumulator can be an array, string, object or a transformer. Iterated items will
   * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item
   * arrays will be merged as key, value pairs.
   *
   * The accumulator can also be a transformer object that provides a 2-arity reducing iterator
   * function, step, 0-arity initial value function, init, and 1-arity result extraction function
   * result. The step function is used as the iterator function in reduce. The result function is
   * used to convert the final accumulator into the return type and in most cases is R.identity.
   * The init function is used to provide the initial accumulator.
   *
   * The iteration is performed with R.reduce after initializing the transducer.
   *
   * @func
   * @memberOf R
   * @category List
   * @sig a -> (b -> b) -> [c] -> a
   * @param {*} acc The initial accumulator value.
   * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @example
   *
   *      var numbers = [1, 2, 3, 4];
   *      var transducer = R.compose(R.map(R.add(1)), R.take(2));
   *
   *      R.into([], transducer, numbers); //=> [2, 3]
   *
   *      var intoArray = R.into([]);
   *      intoArray(transducer, numbers); //=> [2, 3]
   */
  module.exports = _curry3(function into(acc, xf, list) {
    return _isTransformer(acc) ? _reduce(xf(acc), acc.init(), list)
                               : _reduce(xf(_stepCat(acc)), acc, list);
  });
  