Mirrors/lodash
1
0
Fork 0
mirror of https://github.com/whoisclebs/lodash.git synced 2026-02-07 18:07:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Adjust lazy heuristic to punt if not using shortcut fusion.

Browse Source
This commit is contained in:
jdalton
2015-06-06 15:30:56 -07:00
parent ab981ce15a
commit ba082b74a7
2 changed files with 51 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lodash.src.js
View File

@@ -1179,7 +1179,7 @@
resIndex = 0, resIndex = 0,
takeCount = nativeMin(length, this.__takeCount__); takeCount = nativeMin(length, this.__takeCount__);
if (!isArr || array.length < LARGE_ARRAY_SIZE || (iterLength < 2 && arrLength == length && takeCount == length)) { if (!isArr || arrLength < LARGE_ARRAY_SIZE || (arrLength == length && takeCount == length)) {
return baseWrapperValue(isRight ? array.reverse() : array, this.__actions__); return baseWrapperValue(isRight ? array.reverse() : array, this.__actions__);
} }
var result = []; var result = [];

100
test/test.js
View File

@@ -4911,34 +4911,34 @@
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
array = _.range(1, LARGE_ARRAY_SIZE + 1), array = _.range(0, LARGE_ARRAY_SIZE + 1),
expected = [square(LARGE_ARRAY_SIZE), LARGE_ARRAY_SIZE - 1, _.map(array, square)]; expected = [square(LARGE_ARRAY_SIZE), LARGE_ARRAY_SIZE - 1, _.map(array.slice(1), square)];
_(array).takeRightWhile(function(value, index, array) { _(array).slice(1).takeRightWhile(function(value, index, array) {
args = slice.call(arguments) args = slice.call(arguments)
}).value(); }).value();
deepEqual(args, [LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE - 1, array]); deepEqual(args, [LARGE_ARRAY_SIZE, LARGE_ARRAY_SIZE - 1, array.slice(1)]);
_(array).map(square).takeRightWhile(function(value, index, array) { _(array).slice(1).map(square).takeRightWhile(function(value, index, array) {
args = slice.call(arguments) args = slice.call(arguments)
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
_(array).map(square).takeRightWhile(function(value, index) { _(array).slice(1).map(square).takeRightWhile(function(value, index) {
args = slice.call(arguments) args = slice.call(arguments)
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
_(array).map(square).takeRightWhile(function(index) { _(array).slice(1).map(square).takeRightWhile(function(index) {
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
deepEqual(args, [square(LARGE_ARRAY_SIZE)]); deepEqual(args, [square(LARGE_ARRAY_SIZE)]);
_(array).map(square).takeRightWhile(function() { _(array).slice(1).map(square).takeRightWhile(function() {
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
@@ -5036,34 +5036,34 @@
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
array = _.range(1, LARGE_ARRAY_SIZE + 1), array = _.range(0, LARGE_ARRAY_SIZE + 1),
expected = [1, 0, _.map(array, square)]; expected = [1, 0, _.map(array.slice(1), square)];
_(array).takeWhile(function(value, index, array) { _(array).slice(1).takeWhile(function(value, index, array) {
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
deepEqual(args, [1, 0, array]); deepEqual(args, [1, 0, array.slice(1)]);
_(array).map(square).takeWhile(function(value, index, array) { _(array).slice(1).map(square).takeWhile(function(value, index, array) {
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
_(array).map(square).takeWhile(function(value, index) { _(array).slice(1).map(square).takeWhile(function(value, index) {
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
_(array).map(square).takeWhile(function(value) { _(array).slice(1).map(square).takeWhile(function(value) {
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
deepEqual(args, [1]); deepEqual(args, [1]);
_(array).map(square).takeWhile(function() { _(array).slice(1).map(square).takeWhile(function() {
args = slice.call(arguments); args = slice.call(arguments);
}).value(); }).value();
@@ -9418,38 +9418,38 @@
test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
array = _.range(1, LARGE_ARRAY_SIZE + 1), array = _.range(0, LARGE_ARRAY_SIZE),
expected = [1, 0, _.map(array, square)]; expected = [1, 0, _.map(array.slice(1), square)];
_(array).map(function(value, index, array) { _(array).slice(1).map(function(value, index, array) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, [1, 0, array]); deepEqual(args, [1, 0, array.slice(1)]);
args = null; args = null;
_(array).map(square).map(function(value, index, array) { _(array).slice(1).map(square).map(function(value, index, array) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
args = null; args = null;
_(array).map(square).map(function(value, index) { _(array).slice(1).map(square).map(function(value, index) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
args = null; args = null;
_(array).map(square).map(function(value) { _(array).slice(1).map(square).map(function(value) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, [1]); deepEqual(args, [1]);
args = null; args = null;
_(array).map(square).map(function() { _(array).slice(1).map(square).map(function() {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
@@ -12273,15 +12273,15 @@
test('should work in a lazy chain sequence', 2, function() { test('should work in a lazy chain sequence', 2, function() {
if (!isNpm) { if (!isNpm) {
var array = _.times(LARGE_ARRAY_SIZE, function(index) { var array = _.times(LARGE_ARRAY_SIZE + 1, function(index) {
return index ? { 'a': index } : null; return index ? { 'a': index } : null;
}); });
var actual = _(array).pluck('a').value(); var actual = _(array).slice(1).pluck('a').value();
deepEqual(actual, _.pluck(array, 'a')); deepEqual(actual, _.pluck(array.slice(1), 'a'));
actual = _(array).filter().pluck('a').value(); actual = _(array).slice(1).filter().pluck('a').value();
deepEqual(actual, _.pluck(_.filter(array), 'a')); deepEqual(actual, _.pluck(_.filter(array.slice(1)), 'a'));
} }
else { else {
skipTest(2); skipTest(2);
@@ -13184,11 +13184,11 @@
test('`_.' + methodName + '` should work in a lazy chain sequence', 2, function() { test('`_.' + methodName + '` should work in a lazy chain sequence', 2, function() {
if (!isNpm) { if (!isNpm) {
var array = _.range(1, LARGE_ARRAY_SIZE + 1), var array = _.range(0, LARGE_ARRAY_SIZE + 1),
predicate = function(value) { return isFilter ? (value > 6) : (value < 6); }, predicate = function(value) { return isFilter ? (value > 6) : (value < 6); },
actual = _(array).map(square)[methodName](predicate).value(); actual = _(array).slice(1).map(square)[methodName](predicate).value();
deepEqual(actual, _[methodName](_.map(array, square), predicate)); deepEqual(actual, _[methodName](_.map(array.slice(1), square), predicate));
var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) { var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) {
return ['key' + index, index]; return ['key' + index, index];
@@ -13205,38 +13205,38 @@
test('`_.' + methodName + '` should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() { test('`_.' + methodName + '` should provide the correct `predicate` arguments in a lazy chain sequence', 5, function() {
if (!isNpm) { if (!isNpm) {
var args, var args,
array = _.range(1, LARGE_ARRAY_SIZE + 1), array = _.range(0, LARGE_ARRAY_SIZE + 1),
expected = [1, 0, _.map(array, square)]; expected = [1, 0, _.map(array.slice(1), square)];
_(array)[methodName](function(value, index, array) { _(array).slice(1)[methodName](function(value, index, array) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, [1, 0, array]); deepEqual(args, [1, 0, array.slice(1)]);
args = null; args = null;
_(array).map(square)[methodName](function(value, index, array) { _(array).slice(1).map(square)[methodName](function(value, index, array) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
args = null; args = null;
_(array).map(square)[methodName](function(value, index) { _(array).slice(1).map(square)[methodName](function(value, index) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, expected); deepEqual(args, expected);
args = null; args = null;
_(array).map(square)[methodName](function(value) { _(array).slice(1).map(square)[methodName](function(value) {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
deepEqual(args, [1]); deepEqual(args, [1]);
args = null; args = null;
_(array).map(square)[methodName](function() { _(array).slice(1).map(square)[methodName](function() {
args || (args = slice.call(arguments)); args || (args = slice.call(arguments));
}).value(); }).value();
@@ -15920,17 +15920,17 @@
test('should work in a lazy chain sequence', 2, function() { test('should work in a lazy chain sequence', 2, function() {
if (!isNpm) { if (!isNpm) {
var array = _.range(1, LARGE_ARRAY_SIZE + 1), var array = _.range(0, LARGE_ARRAY_SIZE + 1),
actual = _(array).map(String).toArray().value(); actual = _(array).slice(1).map(String).toArray().value();
deepEqual(actual, _.map(array, String)); deepEqual(actual, _.map(array.slice(1), String));
var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) { var object = _.zipObject(_.times(LARGE_ARRAY_SIZE, function(index) {
return ['key' + index, index]; return ['key' + index, index];
})); }));
actual = _(object).toArray().map(String).value(); actual = _(object).toArray().slice(1).map(String).value();
deepEqual(actual, _.map(_.toArray(object), String)); deepEqual(actual, _.map(_.toArray(object).slice(1), String));
} }
else { else {
skipTest(2); skipTest(2);
@@ -16663,12 +16663,12 @@
test('should work in a lazy chain sequence', 1, function() { test('should work in a lazy chain sequence', 1, function() {
if (!isNpm) { if (!isNpm) {
var array = _.times(LARGE_ARRAY_SIZE, function(index) { var array = _.times(LARGE_ARRAY_SIZE + 1, function(index) {
return index ? { 'a': 1, 'b': index } : { 'a': 3 }; return index ? { 'a': 1, 'b': index } : { 'a': 3 };
}); });
var actual = _(array).where({ 'a': 1 }).value(); var actual = _(array).slice(1).where({ 'a': 1 }).value();
deepEqual(actual, _.where(array, { 'a': 1 })); deepEqual(actual, _.where(array.slice(1), { 'a': 1 }));
} }
else { else {
skipTest(); skipTest();
@@ -17285,8 +17285,8 @@
}; };
try { try {
var array = _.range(1, LARGE_ARRAY_SIZE).concat(spy), var array = _.range(0, LARGE_ARRAY_SIZE).concat(spy),
wrapped = _(array).map(String).reverse(), wrapped = _(array).slice(1).map(String).reverse(),
actual = wrapped.last(); actual = wrapped.last();
} catch(e) {} } catch(e) {}