How to use

reduceRight

function

in

Array

function compose() {
 for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
  funcs[_key] = arguments[_key];
 }

 return function (arg) {
  return funcs.reduceRight(function (composed, f) {
   return f(composed);
  }, arg);
 };
}

it('should return the expected result with a string', function () {
  proclaim.deepEqual(Array.prototype.reduceRight.call('1234567', function (a, b) {
    return String(a || '') + String(b || '');
  }), [7,6,5,4,3,2,1].join(''));
});

/**
   * Reduce right
   * @param args
   * @return {*}
   */
  reduceRight(...args) {
    let A = this.toArray();
    let result = A.reduceRight(...args);
    this.applyArray(A);
    return result;
  }

withContext.reduceRight(function (previous, renderRouterContext) {
   return renderRouterContext(previous, renderProps);
  }, _react2.default.createElement(_RouterContext2.default, _extends({}, renderProps, {
   createElement: makeCreateElement(renderProps.createElement)
  })))

test('@arr/reduceRight', t => {
  const a = fn(foo, (x,y) => x + y);
  const b = foo.reduceRight((x,y) => x + y);
  t.equal(a, b, 'matches native output');
  t.equal(a, 6, 'is expected output');

  const x = fn(bar, (j,k) => j.concat(k), []);
  const y = bar.reduceRight((j,k) => j.concat(k), []);
  t.deepEqual(x, y, 'matches native output');
  t.deepEqual(x, [4,5,2,3,0,1], 'is expected output');
  t.end();
});

const and = (...conditions) => resolver => {
 return conditions.reduceRight((p, c) => {
  return c.createResolver(p);
 }, resolver)
}

function compose(...fns) {
  return function (...args) {
    let last = fns.pop();//最后一个函数 addFirst
    return fns.reduceRight(function (prev, next, curIndex, arr) {
      return next(prev);
    }, last(...args));
  }
}

/* globals proclaim */

it('is a function', function () {
  proclaim.isFunction(Array.prototype.reduceRight);
});

var makeCreateElement = function makeCreateElement() {
  var baseCreateElement = arguments.length <= 0 || arguments[0] === undefined ? _react.createElement : arguments[0];
  return function (Component, props) {
   return withComponent.reduceRight(function (previous, renderRouteComponent) {
    return renderRouteComponent(previous, props);
   }, baseCreateElement(Component, props));
  };
 }

/**
   * @see Array#reduceRight
   * @param callback
   * @param initialValue
   * @returns {*}
   */
  reduceRight(callback, initialValue){
    return this._items.reduceRight(callback, initialValue);
  }

it('should not affect elements added to the array after it has begun', function () {
  var arr = [1,2,3], i = 0;
  arr.reduceRight(function (a, b) {
    i++;
    if (i <= 4) {
      arr.push(a + 3);
    }
    return b;
  });
  proclaim.deepEqual(arr, [1,2,3,6,5]);
  proclaim.equal(i, 2);
});

it('should skip non-set values', function () {
  var test = [1,2,3];
  delete test[1];
  var visited = {};
  test.reduceRight(function (a, b) {
    if (a) { visited[a] = true; }
    if (b) { visited[b] = true; }
    return 0;
  });
  proclaim.deepEqual(visited, { 1: true, 3: true });
});

it('should not directly affect the passed array', function () {
  var test = [1,2,3];
  var copy = [1,2,3];
  test.reduceRight(function (a, b) {
    return a + b;
  });
  proclaim.deepEqual(test, copy);
});

//store.getState store.dispatch
// let old = store.dispatch;//存一下以前的方法
//改写了dispatch的方法
function compose(...fns) {
  return function (...args) {
    let last = fns.pop();//最后一个函数 addFirst
    return fns.reduceRight(function (prev, next, curIndex, arr) {
      return next(prev);
    }, last(...args));
  }
}

var makeCreateElement = function makeCreateElement() {
  var baseCreateElement = arguments.length <= 0 || arguments[0] === undefined ? _react.createElement : arguments[0];
  return function (Component, props) {
   return withComponent.reduceRight(function (previous, renderRouteComponent) {
    return renderRouteComponent(previous, props);
   }, baseCreateElement(Component, props));
  };
 }