moy-fp
Version:
A functional programming library.
2,155 lines (1,911 loc) • 61.3 kB
JavaScript
/**
* moy-fp v1.3.5
* (jp) 2018 murakami
* @license MIT
*/
/**
* functional parameter placeholder
*/
var __ = Symbol('functional parameter placeholder');
var _arity = function _arity(n, fn) {
/* eslint-disable no-unused-vars */
switch (n) {
case 0:
return function () {
return fn.apply(null, arguments);
};
case 1:
return function (a0) {
return fn.apply(null, arguments);
};
case 2:
return function (a0, a1) {
return fn.apply(null, arguments);
};
case 3:
return function (a0, a1, a2) {
return fn.apply(null, arguments);
};
case 4:
return function (a0, a1, a2, a3) {
return fn.apply(null, arguments);
};
case 5:
return function (a0, a1, a2, a3, a4) {
return fn.apply(null, arguments);
};
case 6:
return function (a0, a1, a2, a3, a4, a5) {
return fn.apply(null, arguments);
};
case 7:
return function (a0, a1, a2, a3, a4, a5, a6) {
return fn.apply(null, arguments);
};
case 8:
return function (a0, a1, a2, a3, a4, a5, a6, a7) {
return fn.apply(null, arguments);
};
case 9:
return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
return fn.apply(null, arguments);
};
case 10:
return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
return fn.apply(null, arguments);
};
default:
return function () {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return fn.apply(null, arguments);
};
}
};
var _curry = function _curry(length, received, fn) {
return function () {
var combined = [],
receivedLength = received.length,
argsLength = arguments.length;
var left = length,
receivedIndex = 0,
argsIndex = 0,
has__ = false,
combinedOne = void 0;
while (receivedIndex < receivedLength || argsIndex < argsLength) {
if (receivedIndex < receivedLength && (received[receivedIndex] !== __ || argsIndex >= argsLength)) {
combinedOne = received[receivedIndex];
} else {
var _ref;
combinedOne = (_ref = argsIndex++, arguments.length <= _ref ? undefined : arguments[_ref]);
}
if (combinedOne !== __) {
left--;
} else {
if (combined.length <= length) {
has__ = true;
}
}
combined.push(combinedOne);
receivedIndex++;
}
return left <= 0 && !has__ ? fn.apply(null, combined) : _arity(left, _curry(length, combined, fn));
};
};
/**
* ((a, b, c, ..., m) -> n) -> ((a, b, c, ..., m) -> n)
*/
var curry = function curry(fn) {
var length = fn.length;
return _arity(length, _curry(length, [], fn));
};
/**
* a -> (*... -> a)
*/
var always = curry(function (x) {
return function () {
return x;
};
});
/**
* a -> (a -> b) -> b
*/
var applyTo = curry(function (x, fn) {
return fn(x);
});
/**
* Ord b => (a -> b) -> a -> a -> Number
*/
var ascend = curry(function (fn, a, b) {
var aa = fn(a),
bb = fn(b);
return aa > bb ? 1 : aa === bb ? 0 : -1;
});
/**
* Number -> ((a, b, ..., m) -> n) -> ((a, b, ..., m) -> n)
*/
var nAry = curry(function (n, fn) {
switch (n) {
case 0:
return curry(function () {
return fn();
});
case 1:
return curry(function (a0) {
return fn(a0);
});
case 2:
return curry(function (a0, a1) {
return fn(a0, a1);
});
case 3:
return curry(function (a0, a1, a2) {
return fn(a0, a1, a2);
});
case 4:
return curry(function (a0, a1, a2, a3) {
return fn(a0, a1, a2, a3);
});
case 5:
return curry(function (a0, a1, a2, a3, a4) {
return fn(a0, a1, a2, a3, a4);
});
case 6:
return curry(function (a0, a1, a2, a3, a4, a5) {
return fn(a0, a1, a2, a3, a4, a5);
});
case 7:
return curry(function (a0, a1, a2, a3, a4, a5, a6) {
return fn(a0, a1, a2, a3, a4, a5, a6);
});
case 8:
return curry(function (a0, a1, a2, a3, a4, a5, a6, a7) {
return fn(a0, a1, a2, a3, a4, a5, a6, a7);
});
case 9:
return curry(function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
return fn(a0, a1, a2, a3, a4, a5, a6, a7, a8);
});
case 10:
return curry(function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
return fn(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
});
default:
return curry(function () {
return fn.apply(undefined, arguments);
});
}
});
/**
* (*... -> c) -> ((a, b) -> c)
*/
var binary = nAry(2);
/**
* ((a, b) -> Boolean) -> ((a, b) -> Number)
*/
var comparator = curry(function (pred) {
return curry(function (a, b) {
return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;
});
});
/**
* ((y -> z) -> (x -> y) -> ... -> (a -> b)) -> (a -> z)
*/
var compose = function compose() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return function (x) {
return args.reduceRight(applyTo, x);
};
};
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
var defineProperty = function (obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
};
var slicedToArray = function () {
function sliceIterator(arr, i) {
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
try {
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"]) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
return function (arr, i) {
if (Array.isArray(arr)) {
return arr;
} else if (Symbol.iterator in Object(arr)) {
return sliceIterator(arr, i);
} else {
throw new TypeError("Invalid attempt to destructure non-iterable instance");
}
};
}();
var toConsumableArray = function (arr) {
if (Array.isArray(arr)) {
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
return arr2;
} else {
return Array.from(arr);
}
};
/**
* [(x1, x2, ...) -> a, (x1, x2, ...) -> b, ..., (x1, x2, ...) -> m] -> ((a, b, ..., m) -> n) -> ((x1, x2, ...) -> n)
*/
var converge = curry(function (fns, after) {
return nAry(fns.reduce(function (acc, fn) {
return Math.max(acc, fn.length);
}, 0), function () {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return after.apply(undefined, toConsumableArray(fns.map(function (fn) {
return fn.apply(undefined, args);
})));
});
});
/**
* Ord b => (a -> b) -> a -> a -> Number
*/
var descend = curry(function (fn, a, b) {
var aa = fn(a),
bb = fn(b);
return aa > bb ? -1 : aa === bb ? 0 : 1;
});
/**
* * -> String
*/
var is = curry(function (x) {
return Object.prototype.toString.call(x).slice(8, -1);
});
/**
* a -> a | undefined
*/
var empty = curry(function (x) {
if (x.empty) {
return x.empty();
}
switch (is(x)) {
case 'String':
return '';
case 'Array':
return [];
case 'Object':
return {};
default:
}
});
/**
* ((a, b, ..., m) -> n) -> ((b, a, ..., m) -> n)
*/
var flip = curry(function (fn) {
return nAry(fn.length, function (a, b) {
for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
args[_key - 2] = arguments[_key];
}
return fn.apply(undefined, [b, a].concat(args));
});
});
/**
* Number -> [a] -> a | undefined
*/
var nthList = curry(function (n, list) {
return list[n >= 0 ? n : n + list.length];
});
/**
* [a] -> a | undefined
*/
var LastList = nthList(-1);
/**
* Number -> String -> ((a, b, ..., m, Object) -> *)
*/
var invoker = curry(function (n, method) {
return nAry(n + 1, function () {
var _lastList;
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return (_lastList = LastList(args))[method].apply(_lastList, toConsumableArray(args.slice(0, -1)));
});
});
/**
* [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n])
*/
var juxt = converge(__, Array.of);
/**
* (b -> c) -> (a -> b) -> a -> c
*/
var o = curry(function (g, f, x) {
return g(f(x));
});
/**
* (a -> *) -> a -> a
*/
var tap = curry(function (fn, x) {
fn(x);
return x;
});
/**
* (*... -> b) -> (a -> b)
*/
var unary = nAry(1);
/**
* Identity is a Functor, Monad and Applicative
* can map
* can join
* can chain
* can ap
* always use for containing a value in a box
* you may not need it if you are not sensitive in functional programming
*/
var Identity = function Identity(value) {
var _Object$create;
return Object.seal(Object.create(null, (_Object$create = {
value: {
value: value
}
}, defineProperty(_Object$create, Symbol.toStringTag, {
value: 'Identity'
}), defineProperty(_Object$create, 'map', {
value: function map(fn) {
return Identity.of(fn(this.value));
}
}), defineProperty(_Object$create, 'join', {
value: function join() {
return this.value;
}
}), defineProperty(_Object$create, 'chain', {
value: function chain(fn) {
return fn(this.value);
}
}), defineProperty(_Object$create, 'ap', {
value: function ap(I) {
return I.map(this.value);
}
}), _Object$create)));
};
/**
* Functor Identity => a -> Identity a
*/
Identity.of = Identity;
/**
* IO is a Functor, Monad and Applicative
* can map
* can join
* can chain
* can ap
* always use for IO(input and output) and side effects
* you may not need it if you are not sensitive in functional programming
*/
var IO = function IO(unsafePerformIO) {
var _Object$create;
return Object.seal(Object.create(null, (_Object$create = {
unsafePerformIO: {
value: unsafePerformIO
}
}, defineProperty(_Object$create, Symbol.toStringTag, {
value: 'IO'
}), defineProperty(_Object$create, 'map', {
value: function map(fn) {
var _this = this;
return IO(function () {
return fn(_this.unsafePerformIO());
});
}
}), defineProperty(_Object$create, 'join', {
value: function join() {
return this.chain(function (x) {
return x;
});
}
}), defineProperty(_Object$create, 'chain', {
value: function chain(fn) {
var _this2 = this;
return IO(function () {
return fn(_this2.unsafePerformIO()).unsafePerformIO();
});
}
}), defineProperty(_Object$create, 'ap', {
value: function ap(I) {
return this.chain(function (fn) {
return I.map(fn);
});
}
}), _Object$create)));
};
/**
* Functor IO => a -> IO a
*/
IO.of = function (x) {
return IO(function () {
return x;
});
};
/**
* Maybe is a Functor, Monad and Applicative
* can map
* can join
* can chain
* can ap
* always use for dividing value for two typs(null type and no null type)
* null value cannot do any notaion, just return Maybe(null)
* no null value can do notation, return handled result
* also can use like Either Functor do if you'd like(I prefer using Maybe, so no Either here)
* you may not need it if you are not sensitive in functional programming
*/
var Maybe = function Maybe(value) {
var _Object$create;
return Object.seal(Object.create(null, (_Object$create = {
value: {
value: value
}
}, defineProperty(_Object$create, Symbol.toStringTag, {
value: 'Maybe'
}), defineProperty(_Object$create, 'map', {
value: function map(fn) {
return this.value === null || this.value === undefined ? this : Maybe.of(fn(this.value));
}
}), defineProperty(_Object$create, 'join', {
value: function join() {
return this.value === null || this.value === undefined ? this : this.value;
}
}), defineProperty(_Object$create, 'chain', {
value: function chain(fn) {
return this.map(fn).join();
}
}), defineProperty(_Object$create, 'ap', {
value: function ap(M) {
return this.value === null || this.value === undefined ? this : M.map(this.value);
}
}), _Object$create)));
};
/**
* Functor Maybe => a -> Maybe a
*/
Maybe.of = Maybe;
/**
* Task is a Functor, Monad and Applicative
* can map
* can join
* can chain
* can ap
* always use for asynchronous task and side effects
* can also handle synchronous task if you'd like
* a super Functor, can't convert to other Functor, but other Functor can easy convert to Task
* you may not need it if you are not sensitive in functional programming
*/
var Task = function Task(fork) {
var _Object$create;
return Object.seal(Object.create(null, (_Object$create = {
fork: {
value: fork
}
}, defineProperty(_Object$create, Symbol.toStringTag, {
value: 'Task'
}), defineProperty(_Object$create, 'map', {
value: function map(fn) {
var _this = this;
return Task(function (reject, resolve) {
return _this.fork(reject, function (x) {
return resolve(fn(x));
});
});
}
}), defineProperty(_Object$create, 'join', {
value: function join() {
return this.chain(function (x) {
return x;
});
}
}), defineProperty(_Object$create, 'chain', {
value: function chain(fn) {
var _this2 = this;
return Task(function (reject, resolve) {
return _this2.fork(reject, function (x) {
return fn(x).fork(reject, resolve);
});
});
}
}), defineProperty(_Object$create, 'ap', {
value: function ap(T) {
return this.chain(function (fn) {
return T.map(fn);
});
}
}), _Object$create)));
};
/**
* Functor Task => a -> Task a
*/
Task.of = function (x) {
return Task(function (_, resolve) {
return resolve(x);
});
};
/**
* Functor f => f (a -> b) -> f a -> f b
*/
var ap = curry(function (F2, F1) {
return Object.prototype.toString.call(F1) === '[object Array]' ? F2.reduce(function (acc, cur) {
return acc.concat(F1.map(cur));
}, []) : F2.ap(F1);
});
/**
* Functor f => (a -> f b) -> f a -> f b
*/
var chain = curry(function (fn, F) {
return Object.prototype.toString.call(F) === '[object Array]' ? F.reduce(function (acc, cur) {
return acc.concat(fn(cur));
}, []) : F.chain(fn);
});
/**
* Functor f => f a -> a
* [a] -> [a]
*/
var extract = curry(function (F) {
switch (Object.prototype.toString.call(F)) {
case '[object Identity]':
return F.value;
case '[object Maybe]':
return F.value === null || F.value === undefined ? null : F.value;
case '[object IO]':
return F.unsafePerformIO;
case '[object Task]':
return F.fork;
case '[object Array]':
return F;
default:
return;
}
});
/**
* Task T => (a -> c) -> (a -> b) -> T a -> ()
*/
var fork = curry(function (reject, resolve, task) {
return task.fork(reject, resolve);
});
/**
* Identity I => I a -> a
*/
var identity = curry(function (I) {
return I.value;
});
/**
* Functor f => f (f a) -> f a
*/
var join = curry(function (F) {
return Object.prototype.toString.call(F) === '[object Array]' ? F.reduce(function (acc, cur) {
return acc.concat(cur);
}, []) : F.join();
});
/**
* Functor f => (a -> b) -> f a -> f b
*/
var map = curry(function (fn, F) {
if (Object.prototype.toString.call(F) === '[object Array]') {
var list = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = F[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
list.push(fn(item));
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return list;
}
return F.map(fn);
});
/**
* Functor f => ((a, b, ..., m) -> n) -> ((f a, f b, ..., f m) -> f n)
*/
var lift = function lift(fn) {
return nAry(fn.length, function (arg) {
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
switch (Object.prototype.toString.call(arg)) {
case '[object Array]':
case '[object Identity]':
case '[object Maybe]':
case '[object IO]':
case '[object Task]':
return args.reduce(ap, map(fn, arg));
default:
return;
}
});
};
/**
* Maybe m => b -> (a -> b) -> m a -> b
*/
var maybe = curry(function (value, fn, m) {
if (m.value === null || m.value === undefined) {
return value;
}
return fn(m.value);
});
/**
* Functor f => f -> a -> f a
*/
var of = curry(function (Functor, value) {
return Functor.of(value);
});
/**
* IO I => I a -> a
*/
var unsafePerformIO = curry(function (io) {
return io.unsafePerformIO();
});
/**
* Number -> (a -> a) -> [a] -> [a]
*/
var adjust = curry(function (n, fn, array) {
var list = [].concat(toConsumableArray(array)),
index = n < 0 ? n + array.length : n;
list[index] = fn(list[index]);
return list;
});
/**
* (a -> Boolean) -> [a] -> Boolean
*/
var all = curry(function (pred, list) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
if (!pred(item)) {
return false;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return true;
});
/**
* (a -> Boolean) -> [a] -> Boolean
*/
var any = curry(function (pred, list) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
if (pred(item)) {
return true;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return false;
});
/**
* Number -> [a] -> [[a]]
*/
var aperture = curry(function (n, array) {
var limit = array.length - n + 1,
list = [];
for (var index = 0; index < limit; index++) {
list.push(array.slice(index, index + n));
}
return list;
});
/**
* a -> [a] -> [a]
*/
var append = curry(function (item, list) {
return [].concat(toConsumableArray(list), [item]);
});
/**
* a -> a -> Boolean
*/
var equals = curry(function (b, a) {
if (Object.is(a, b)) {
return true;
}
var aType = Object.prototype.toString.call(a),
bType = Object.prototype.toString.call(b);
if (aType !== bType) {
return false;
}
if (aType === '[object Array]') {
if (a.length !== b.length) {
return false;
}
var length = a.length;
for (var i = 0; i < length; i++) {
if (!equals(b[i], a[i])) {
return false;
}
}
return true;
}
if (aType === '[object Object]') {
var aEntries = Object.entries(a),
bEntries = Object.entries(b);
if (aEntries.length !== bEntries.length) {
return false;
}
return equals(bEntries, aEntries);
}
if (aType === '[object Function]') {
return a.toString() === b.toString();
}
if (aType === '[object Date]') {
return a.valueOf() === b.valueOf();
}
if (aType === '[object RegExp]') {
return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode && a.dotAll === b.dotAll;
}
return false;
});
/**
* a -> [a] -> Boolean
*/
var contains = curry(function (item, list) {
return any(equals(item), list);
});
/**
* (a -> Boolean) -> [a] -> [a]
*/
var filter = curry(function (pred, array) {
var list = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = array[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
if (pred(item)) {
list.push(item);
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return list;
});
/**
* (a -> Boolean) -> [a] -> a | undefined
*/
var find = curry(function (pred, list) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
if (pred(item)) {
return item;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return;
});
/**
* (a -> Boolean) -> [a] -> Number
*/
var findIndex = curry(function (pred, list) {
var entries = list.entries();
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref = _step.value;
var _ref2 = slicedToArray(_ref, 2);
var index = _ref2[0];
var item = _ref2[1];
if (pred(item)) {
return index;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return -1;
});
/**
* ((a, b) -> a) -> a -> [b] -> a
*/
var foldl = curry(function (fn, acc, list) {
var result = acc;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
result = fn(result, item);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return result;
});
/**
* ((b, a) -> a) -> a -> [b] -> a
*/
var foldr = curry(function (fn, acc, list) {
var index = list.length - 1,
result = acc;
while (index >= 0) {
result = fn(list[index], result);
index--;
}
return result;
});
/**
* [[k, v]] -> {k: v}
*/
var fromPairs = foldl(function (acc, _ref) {
var _ref2 = slicedToArray(_ref, 2),
key = _ref2[0],
value = _ref2[1];
acc[key] = value;
return acc;
}, {});
/**
* a -> [a] -> Number
*/
var indexOf = curry(function (predItem, list) {
var entries = list.entries();
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref = _step.value;
var _ref2 = slicedToArray(_ref, 2);
var index = _ref2[0];
var item = _ref2[1];
if (equals(predItem, item)) {
return index;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return -1;
});
/**
* Number -> a -> [a] -> [a]
*/
var insert = curry(function (n, item, array) {
var list = [].concat(toConsumableArray(array));
list.splice(n, 0, item);
return list;
});
/**
* Number -> [a] -> [a] -> [a]
*/
var insertAll = curry(function (n, items, array) {
var list = [].concat(toConsumableArray(array));
list.splice.apply(list, [n, 0].concat(toConsumableArray(items)));
return list;
});
/**
* String -> [a] -> String
*/
var intercalate = invoker(1, 'join');
/**
* (a -> Boolean) -> [a] -> Boolean
*/
var none = curry(function (pred, list) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
if (pred(item)) {
return false;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return true;
});
/**
* b -> a -> [a, b]
*/
var pair = curry(function (second, first) {
return [first, second];
});
/**
* a -> [a] -> [a]
*/
var prepend = curry(function (item, list) {
return [item].concat(toConsumableArray(list));
});
/**
* Number -> Number -> [Number]
*/
var range = curry(function (start, end) {
var result = [];
while (start < end) {
result.push(start++);
}
return result;
});
/**
* (a -> Boolean) -> [a] -> [a]
*/
var reject = curry(function (pred, array) {
var list = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = array[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
if (!pred(item)) {
list.push(item);
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return list;
});
/**
* Number -> Number -> [a] -> [a]
*/
var remove = curry(function (n, count, array) {
var list = [].concat(toConsumableArray(array));
list.splice(n, count);
return list;
});
/**
* ((a, a) -> Number) -> [a] -> [a]
*/
var sort = invoker(1, 'sort');
/**
* [[a]] -> [[a]]
*/
var transpose = curry(function (list) {
var result = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var innerList = _step.value;
var innerEntries = innerList.entries();
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = innerEntries[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _ref = _step2.value;
var _ref2 = slicedToArray(_ref, 2);
var index = _ref2[0];
var item = _ref2[1];
if (!result[index]) {
result[index] = [];
}
result[index].push(item);
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return result;
});
/**
* * -> String
*/
var toString = curry(function (x) {
switch (Object.prototype.toString.call(x)) {
case '[object Boolean]':
return String(x);
case '[object Date]':
return String(x.valueOf());
case '[object Number]':
return Number.isNaN(x) ? 'NaN' : String(x);
case '[object String]':
return x;
case '[object RegExp]':
return String(x);
case '[object Null]':
return 'null';
case '[object Undefined]':
return 'undefined';
case '[object Array]':
return '[' + x.reduce(function (str, v, index, array) {
return '' + str + toString(v) + (index + 1 === array.length ? '' : ', ');
}, '') + ']';
case '[object Object]':
return '{' + Object.entries(x).reduce(function (str, _ref, index, array) {
var _ref2 = slicedToArray(_ref, 2),
key = _ref2[0],
value = _ref2[1];
return '' + str + key + ': ' + toString(value) + (index + 1 === array.length ? '' : ', ');
}, '') + '}';
case '[object Function]':
return x.name || 'anonymous';
default:
return x.toString ? x.toString() : 'unknownType';
}
});
/**
* [a] -> [a] -> [a]
*/
var union = curry(function (list2, list1) {
var unionObj = {},
delimiter = String.fromCharCode(0),
result = [];
var id = void 0;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list1[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
id = Object.prototype.toString.call(item) + delimiter + toString(item);
if (!unionObj[id]) {
result.push(item);
unionObj[id] = true;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = list2[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _item = _step2.value;
id = Object.prototype.toString.call(_item) + delimiter + toString(_item);
if (!unionObj[id]) {
result.push(_item);
unionObj[id] = true;
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return result;
});
/**
* [a] -> [a]
*/
var uniq = union([]);
/**
* Number -> a -> [a] -> [a]
*/
var update = curry(function (n, item, array) {
var list = [].concat(toConsumableArray(array)),
index = n < 0 ? n + array.length : n;
list[index] = item;
return list;
});
/**
* [b] -> [a] -> [[a, b]]
*/
var xprod = curry(function (list2, list1) {
var list = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list1[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item1 = _step.value;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = list2[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var item2 = _step2.value;
list.push([item1, item2]);
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return list;
});
/**
* [b] -> [a] -> [[a, b]]
*/
var zip = curry(function (list2, list1) {
var list = [],
length = Math.min(list1.length, list2.length);
var index = 0;
while (index < length) {
list.push([list1[index], list2[index++]]);
}
return list;
});
/**
* ((b, a) -> c) -> [b] -> [a] -> [c]
*/
var zipWith = curry(function (fn, list2, list1) {
var list = [],
length = Math.min(list1.length, list2.length);
var index = 0;
while (index < length) {
list.push(fn(list2[index], list1[index++]));
}
return list;
});
/**
* [a] -> [a] -> [a]
*/
var concatList = curry(function (list2, list1) {
return list1.concat(list2);
});
/**
* [a] -> a | undefined
*/
var headList = nthList(0);
/**
* Number -> Number -> [a] -> [a]
*/
var sliceList = invoker(2, 'slice');
/**
* [a] -> [a]
*/
var initList = sliceList(0, -1);
/**
* [a] -> Number
*/
var lengthList = curry(function (list) {
return list.length;
});
/**
* [a] -> [a]
*/
var reverseList = invoker(0, 'reverse');
/**
* [a] -> [a]
*/
var tailList = sliceList(1, Number.POSITIVE_INFINITY);
/**
* [(a, b, ... m) -> Boolean] -> ((a, b, ..., m) -> Boolean)
*/
var allPass = curry(function (preds) {
return nAry(preds.reduce(function (n, p) {
return Math.max(n, p.length);
}, 0), function () {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = preds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var pred = _step.value;
if (!pred.apply(undefined, arguments)) {
return false;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return true;
});
});
/**
* b -> a -> a | b
*/
var and = curry(function (b, a) {
return a && b;
});
/**
* [(a, b, ..., m) -> Boolean] -> ((a, b, ..., m) -> Boolean)
*/
var anyPass = curry(function (preds) {
return nAry(preds.reduce(function (n, p) {
return Math.max(n, p.length);
}, 0), function () {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = preds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var pred = _step.value;
if (pred.apply(undefined, arguments)) {
return true;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return false;
});
});
/**
* ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean)
*/
var both = curry(function (pred2, pred1) {
return allPass([pred2, pred1]);
});
/**
* ((a, b, ..., m) -> n) -> ((a, b, ..., m) -> Boolean)
*/
var complement = curry(function (pred) {
return nAry(pred.length, function () {
return !pred.apply(undefined, arguments);
});
});
/**
* ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean)
*/
var either = curry(function (pred2, pred1) {
return anyPass([pred2, pred1]);
});
/**
* * -> Boolean
*/
var not = curry(function (a) {
return !a;
});
/**
* b -> a -> a | b
*/
var or = curry(function (b, a) {
return a || b;
});
/**
* Number -> Number -> Number
*/
var add = curry(function (b, a) {
return Number(a) + Number(b);
});
/**
* Number -> Number -> Number
*/
var subtract = curry(function (b, a) {
return Number(a) - Number(b);
});
/**
* Number -> Number
*/
var dec = subtract(1);
/**
* Number -> Number -> Number
*/
var divide = curry(function (b, a) {
return Number(a) / Number(b);
});
/**
* Number -> Number
*/
var inc = add(1);
/**
* [Number] -> Number
*/
var mean = curry(function (list) {
return list.reduce(add, 0) / list.length;
});
/**
* [Number] -> Number
*/
var median = curry(function (array) {
var list = array.sort(function (a, b) {
return a - b;
}),
length = list.length;
return length === 0 ? NaN : length % 2 === 0 ? (list[length / 2] + list[length / 2 - 1]) / 2 : list[(length - 1) / 2];
});
/**
* Number -> Number -> Number
*/
var mod = curry(function (b, a) {
return Number(a) % Number(b);
});
/**
* Number -> Number -> Number
*/
var multiply = curry(function (b, a) {
return Number(a) * Number(b);
});
/**
* Number -> Number
*/
var negate = subtract(__, 0);
/**
* k -> v -> {k: v} -> {k: v}
*/
var assoc = curry(function (key, value, obj) {
var result = Object.assign({}, obj);
result[key] = value;
return result;
});
/**
* [k] -> v -> {k: v} -> {k: v}
*/
var assocPath = curry(function (paths, value, obj) {
var key = paths[0],
length = paths.length;
return length === 0 ? obj : length === 1 ? Number.isInteger(key) ? update(key, value, obj) : assoc(key, value, obj) : Number.isInteger(key) ? update(key, assocPath(paths.slice(1), value, obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && Object.hasOwnProperty.call(obj, key) ? obj[key] : []), obj) : assoc(key, assocPath(paths.slice(1), value, obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && Object.hasOwnProperty.call(obj, key) ? obj[key] : {}), obj);
});
/**
* k -> {k: v} -> {k: v}
*/
var dissoc = curry(function (key, obj) {
var result = Object.assign({}, obj);
Reflect.deleteProperty(result, key);
return result;
});
/**
* [k] -> {k: v} -> {k: v}
*/
var dissocPath = curry(function (paths, obj) {
var key = paths[0],
length = paths.length;
return !(obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && Object.hasOwnProperty.call(obj, key)) || length === 0 ? obj : length === 1 ? Number.isInteger(key) ? remove(key, 1, obj) : dissoc(key, obj) : Number.isInteger(key) ? update(key, dissocPath(paths.slice(1), obj[key]), obj) : assoc(key, dissocPath(paths.slice(1), obj[key]), obj);
});
/**
* {k: v} -> [[k, v]]
*/
var entries = curry(function (obj) {
return Object.entries(obj);
});
/**
* k -> {k: v} -> Boolean
*/
var has = curry(function (key, obj) {
return Object.prototype.hasOwnProperty.call(obj, key);
});
/**
* {k: v} -> [k]
*/
var keys = curry(function (obj) {
return Object.keys(obj);
});
/**
* (s -> a) -> ((a, s) -> s) -> Lens s a
* Lens s a = Functor f => (a -> f a) -> s -> f s
*/
var lens = curry(function (getter, setter) {
return curry(function (of, a) {
return of(getter(a)).map(function (focus) {
return setter(focus, a);
});
});
});
/**
* Number -> Lens s a
* Lens s a = Functor f => (a -> f a) -> s -> f s
*/
var lensIndex = curry(function (n) {
return lens(nthList(n))(update(n));
});
/**
* [k] -> {k: v} -> v | undefined
*/
var path = curry(function (paths, obj) {
var key = paths[0],
length = paths.length;
return length === 0 ? obj : obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && Object.hasOwnProperty.call(obj, key) ? length === 1 ? obj[key] : path(paths.slice(1), obj[key]) : undefined;
});
/**
* [k] -> Lens s a
* Lens s a = Functor f => (a -> f a) -> s -> f s
*/
var lensPath = curry(function (p) {
return lens(path(p))(assocPath(p));
});
/**
* k -> {k: v} -> v | undefined
*/
var prop = curry(function (key, obj) {
return obj[key];
});
/**
* k -> Lens s a
* Lens s a = Functor f => (a -> f a) -> s -> f s
*/
var lensProp = curry(function (p) {
return lens(prop(p))(assoc(p));
});
/**
* {k: v} -> {k: v} -> {k: v}
*/
var merge = curry(function (obj2, obj1) {
return Object.assign({}, obj2, obj1);
});
/**
* [k] -> {k: v} -> {k: v}
*/
var omit = curry(function (keys, obj) {
var keysMap = keys.reduce(function (map, key) {
map[key] = true;
return map;
}, {}),
result = {},
entries = Object.entries(obj);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref = _step.value;
var _ref2 = slicedToArray(_ref, 2);
var key = _ref2[0];
var value = _ref2[1];
if (!keysMap[key]) {
result[key] = value;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return result;
});
/**
* ((v, k) -> Boolean) -> {k: v} -> {k: v}
*/
var omitBy = curry(function (fn, obj) {
var result = {},
entries = Object.entries(obj);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref = _step.value;
var _ref2 = slicedToArray(_ref, 2);
var key = _ref2[0];
var value = _ref2[1];
if (!fn(value, key)) {
result[key] = value;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return result;
});
// simple internal Functor Identity
// you can also use external Identity to implement set, but it const more performance
var Identity$1 = function Identity(a) {
return {
value: a,
map: function map(f) {
return Identity(f(this.value));
}
};
};
// here we just use .value, and not use extract or Comonad, assue it has no side effects
/**
* Lens s a -> (a -> a) -> s -> s
* Lens s a = Functor f => (a -> f a) -> s -> f s
*/
var over = curry(function (Lens, fn, a) {
return Lens(function (x) {
return Identity$1(fn(x));
})(a).value;
});
/**
* [k] -> {k: v} -> {k: v}
*/
var pick = curry(function (keys, obj) {
var result = {};
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var key = _step.value;
if (Object.prototype.hasOwnProperty.call(obj, key)) {
result[key] = obj[key];
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return result;
});
/**
* ((v, k) -> Boolean) -> {k: v} -> {k: v}
*/
var pickBy = curry(function (fn, obj) {
var result = {},
entries = Object.entries(obj);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref = _step.value;
var _ref2 = slicedToArray(_ref, 2);
var key = _ref2[0];
var value = _ref2[1];
if (fn(value, key)) {
result[key] = value;
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return result;
});
/**
* [k] -> [{k: v}] -> [{k: v}]
*/
var project = curry(function (keys, list) {
return list.map(pick(keys));
});
// simple internal Functor Identity
// you can also use external Identity to implement set, but it const more performance
var Identity$2 = function Identity(a) {
return {
value: a,
map: function map(f) {
return Identity(f(this.value));
}
};
};
// here we just use .value, and not use extract or Comonad, assue it has no side effects
/**
* Lens s a -> a -> s -> s
* Lens s a = Functor f => (a -> f a) -> s -> f s
*/
var set$1 = curry(function (Lens, v, a) {
return Lens(function () {
return Identity$2(v);
})(a).value;
});
/**
* {k: v} -> [[k, v]]
*/
var toPairs = entries;
/**
* {k: v} -> [v]
*/
var values = curry(function (obj) {
return Object.values(obj);
});
// simple internal Functor Const
// you can also use Identity to implement view, but here better is Const
var Const = function Const(a) {
return {
value: a,
map: function map(f) {
return this;
}
};
};
// here we just use .value, and not use extract or Comonad, assue it has no side effects
/**
* Lens s a -> s -> a
* Lens s a = Functor f => (a -> f a) -> s -> f s
*/
var view = curry(function (Lens, a) {
return Lens(Const)(a).value;
});
/**
* [a] -> [a] -> [a]
*/
var difference = curry(function (list2, list1) {
var differenceObj = {},
delimiter = String.fromCharCode(0),
result = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = list2[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var item = _step.value;
differenceObj[Object.prototype.toString.call(item) + delimiter + toString(item)] = true;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = list1[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _item = _step2.value;
if (!differenceObj[Object.prototype.toString.call(_item) + delimiter + toString(_item)]) {
result.push(_item);
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
t