Comparing version 0.9.0 to 0.10.4
@@ -7,13 +7,15 @@ (function (global, factory) { | ||
var _curry1 = function _curry1 (fn) { | ||
return function __arity_1__ (a0) { | ||
return arguments.length ? fn(a0) : __arity_1__ | ||
function _curry1 (fn) { | ||
return function __curried_unary__ (a0) { | ||
return arguments.length ? fn(a0) : __curried_unary__ | ||
} | ||
} | ||
var _curry2 = function _curry2 (fn) { | ||
return function __arity_2__ (a0, a1) { | ||
function _curry2 (fn) { | ||
return function __curried_binary__ (a0, a1) { | ||
switch (arguments.length) { | ||
case 0: return __arity_2__ | ||
case 1: return _curry1(function __arity_1__ (b0) { return fn(a0, b0) }) | ||
case 0: return __curried_binary__ | ||
case 1: return _curry1(function __curried_unary__ (b0) { | ||
return fn(a0, b0) | ||
}) | ||
default: return fn(a0, a1) | ||
@@ -43,22 +45,37 @@ } | ||
function _arrayEach (f, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
for (; i < len; i++) { | ||
if (f(xs[i], i)) { | ||
return | ||
} | ||
} | ||
} | ||
/** | ||
* all : (a -> Boolean) -> [a] -> Boolean | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var all = _curry2(function all (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
var all = true | ||
for (; i < len; i++) { | ||
if (!fn(xs[i])) { | ||
return false | ||
_arrayEach(function (x) { | ||
if (fn(x)) { | ||
all = false | ||
return true | ||
} | ||
} | ||
return true | ||
}, xs) | ||
return all | ||
}) | ||
/** | ||
* always : a -> * -> a | ||
* | ||
* @since v0.9.0 | ||
*/ | ||
var always = function always (x) { | ||
return function __redash_always__ () { | ||
function always (x) { | ||
return function () { | ||
return x | ||
@@ -69,22 +86,38 @@ } | ||
/** | ||
* any : (a -> Boolean) -> [a] -> Boolean | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var any = _curry2(function any (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
var found = false | ||
for (; i < len; i++) { | ||
if (fn(xs[i])) { | ||
return true | ||
_arrayEach(function (x) { | ||
if (fn(x)) { | ||
return found = true | ||
} | ||
} | ||
return false | ||
}, xs) | ||
return found | ||
}) | ||
var _curry3 = function _curry3 (fn) { | ||
return function __arity_3__ (a0, a1, a2) { | ||
var _concat = [].concat | ||
/** | ||
* append : a -> [a] -> [a] | ||
* | ||
* @since v0.10.0 | ||
*/ | ||
var append = _curry2(function append (x, xs) { | ||
return _concat.call(xs, [x]) | ||
}) | ||
function _curry3 (fn) { | ||
return function _curried_ternary__ (a0, a1, a2) { | ||
switch (arguments.length) { | ||
case 0: return __arity_3__ | ||
case 1: return _curry2(function __arity_2__ (_a1, _a2) { return fn(a0, _a1, _a2) }) | ||
case 2: return _curry1(function __arity_1__ (_a2) { return fn(a0, a1, _a2) }) | ||
case 0: return _curried_ternary__ | ||
case 1: return _curry2(function __curried_binary__ (_a1, _a2) { | ||
return fn(a0, _a1, _a2) | ||
}) | ||
case 2: return _curry1(function __curried_unary__ (_a2) { | ||
return fn(a0, a1, _a2) | ||
}) | ||
default: return fn(a0, a1, a2) | ||
@@ -96,18 +129,20 @@ } | ||
/** | ||
* assoc : String -> * -> {k:v} -> {k:v} | ||
* | ||
* @since v0.6.0 | ||
*/ | ||
var assoc = _curry3(function assoc (p, v, o) { | ||
var b = {} | ||
, prop | ||
var assoc = _curry3(function assoc (k, v, o) { | ||
var y = {} | ||
, p | ||
for (prop in o) { | ||
b[prop] = o[prop] | ||
for (p in o) { | ||
y[p] = o[p] | ||
} | ||
b[p] = v | ||
return b | ||
y[k] = v | ||
return y | ||
}) | ||
var _concat = [].concat | ||
/** | ||
* concat : [a] -> [a] -> [a] | ||
* | ||
* @since v0.7.0 | ||
@@ -119,30 +154,17 @@ */ | ||
/** | ||
* @since v0.9.0 | ||
*/ | ||
var complement = function complement (fn) { | ||
return function () { | ||
return !fn.call(this, arguments) | ||
} | ||
} | ||
var _arraySlice = [].slice | ||
var _slice = [].slice | ||
// Credit to Ramda for this idea for creating curried functions that | ||
// properly report their arity via function.length. | ||
// https://github.com/ramda/ramda/blob/master/src/internal/_arity.js | ||
var _arity = function _arity (arity, fn) { | ||
function _arity (arity, fn) { | ||
switch (arity) { | ||
case 0: return function __arity_0__ () { return fn.apply(this, arguments) } | ||
case 1: return function __arity_1__ (a0) { return fn.apply(this, arguments) } | ||
case 2: return function __arity_2__ (a0, a1) { return fn.apply(this, arguments) } | ||
case 3: return function __arity_3__ (a0, a1, a2) { return fn.apply(this, arguments) } | ||
case 4: return function __arity_4__ (a0, a1, a2, a3) { return fn.apply(this, arguments) } | ||
case 5: return function __arity_5__ (a0, a1, a2, a3, a4) { return fn.apply(this, arguments) } | ||
case 6: return function __arity_6__ (a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments) } | ||
case 7: return function __arity_7__ (a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments) } | ||
case 8: return function __arity_8__ (a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments) } | ||
case 9: return function __arity_9__ (a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments) } | ||
case 10: return function __arity_10__ (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments) } | ||
default: throw new Error('Arity must be less than or equal to 10.') | ||
case 0: return function () { return fn.apply(this, arguments) } | ||
case 1: return function (a0) { return fn.apply(this, arguments) } | ||
case 2: return function (a0, a1) { return fn.apply(this, arguments) } | ||
case 3: return function (a0, a1, a2) { return fn.apply(this, arguments) } | ||
case 4: return function (a0, a1, a2, a3) { return fn.apply(this, arguments) } | ||
case 5: return function (a0, a1, a2, a3, a4) { return fn.apply(this, arguments) } | ||
case 6: return function (a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments) } | ||
default: throw new Error('Arity must be less than or equal to 6.') | ||
} | ||
@@ -172,3 +194,3 @@ } | ||
if (arguments.length) { | ||
newApplied = _slice.call(applied) | ||
newApplied = _arraySlice.call(applied) | ||
for (i = 0; i < arguments.length; i++) { | ||
@@ -186,26 +208,28 @@ newApplied.push(arguments[i]) | ||
/** | ||
* @since v0.1.0 | ||
* complement : (*... -> Boolean) -> (*... -> Boolean) | ||
* | ||
* @since v0.9.0 | ||
*/ | ||
var curryN = _curry2(function curryN (arity, fn) { | ||
switch (arity) { | ||
case 0: return fn | ||
case 1: return _curry1(fn) | ||
case 2: return _curry2(fn) | ||
case 3: return _curry3(fn) | ||
default: return _curryN(fn.length, [], fn) | ||
} | ||
}) | ||
function complement (fn) { | ||
return _curryN(fn.length, [], function () { | ||
return !fn.apply(this, arguments) | ||
}) | ||
} | ||
var _reverse = [].reverse | ||
/** | ||
* pipe : ((a, b, ..., f -> g), (g -> h), ..., (y -> z)) -> ((a, b, ..., f) -> z | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var compose = function compose () { | ||
function pipe () { | ||
var fns = arguments | ||
, i = fns.length - 1 | ||
, fn = fns[i--] | ||
return curryN(fn.length, function __composition__ () { | ||
var y = fn.apply(null, arguments) | ||
return _curryN(fns[0].length, [], function () { | ||
var i = 0 | ||
, len = fns.length | ||
, y = fns[i++].apply(null, arguments) | ||
for (; i >= 0; i--) { | ||
for (; i < len; i++) { | ||
y = fns[i](y) | ||
@@ -218,6 +242,17 @@ } | ||
/** | ||
* compose : (y -> z), ..., (g -> h), (a, b, ..., f -> g) -> (a, b, ..., f -> z) | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var curry = function curry (fn) { | ||
switch (fn.length) { | ||
function compose () { | ||
return pipe.apply(this, _reverse.call(arguments)) | ||
} | ||
/** | ||
* curryN : Number n -> (a, b, ..., n -> v) -> a -> b -> ... -> n -> v | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var curryN = _curry2(function curryN (arity, fn) { | ||
switch (arity) { | ||
case 0: return fn | ||
@@ -227,14 +262,56 @@ case 1: return _curry1(fn) | ||
case 3: return _curry3(fn) | ||
default: return _curryN(fn.length, [], fn) | ||
default: | ||
return _curryN(arity, [], fn) | ||
} | ||
}) | ||
/** | ||
* curry : (a, b, ..., j -> v) -> a -> b -> ... -> j -> v | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
function curry (fn) { | ||
return curryN(fn.length, fn) | ||
} | ||
/** | ||
* dec : Number -> Number | ||
* | ||
* @since v0.6.0 | ||
*/ | ||
var dec = function dec (a) { | ||
function dec (a) { | ||
return a - 1 | ||
} | ||
var _equals = function _equals (a, b) { | ||
/** | ||
* dissoc : String -> {k:v} -> {k:v} | ||
* | ||
* @since v0.10.0 | ||
*/ | ||
var dissoc = _curry2(function dissoc (k, kv) { | ||
var y = {} | ||
, p | ||
for (p in kv) { | ||
if (p !== k) { | ||
y[p] = kv[p] | ||
} | ||
} | ||
return y | ||
}) | ||
function _slice (xs, from, to) { | ||
return _arraySlice.call(xs, from, to) | ||
} | ||
/** | ||
* drop : Number -> Array -> Array | ||
* | ||
* @since v0.10.0 | ||
*/ | ||
var drop = _curry2(function drop (n, xs) { | ||
return _slice(xs, n) | ||
}) | ||
function _equals (a, b) { | ||
return a === b | ||
@@ -244,23 +321,21 @@ } | ||
/** | ||
* equals : a -> a -> Boolean | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var equals = _curry2(function equals (a, b) { | ||
return _equals(a, b) | ||
}) | ||
var equals = _curry2(_equals) | ||
/** | ||
* filter : (a -> Boolean) -> [a] -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var filter = _curry2(function filter (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
, ys = [] | ||
, x | ||
var ys = [] | ||
for (; i < len; i++) { | ||
x = xs[i] | ||
_arrayEach(function (x) { | ||
if (fn(x)) { | ||
ys.push(x) | ||
} | ||
} | ||
}, xs) | ||
return ys | ||
@@ -270,52 +345,53 @@ }) | ||
/** | ||
* find : (a -> Boolean) -> [a] -> a | undefined | ||
* | ||
* @since v0.6.0 | ||
*/ | ||
var find = _curry2(function find (pred, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
, x | ||
var y | ||
for (; i < len; i++) { | ||
x = xs[i] | ||
_arrayEach(function (x) { | ||
if (pred(x)) { | ||
return x | ||
y = x | ||
return true | ||
} | ||
} | ||
}, xs) | ||
return y | ||
}) | ||
/** | ||
* findIndex : (a -> Boolean) -> [a] -> Number | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var findIndex = _curry2(function findIndex (pred, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
var _i = -1 | ||
for (; i < len; i++) { | ||
if (pred(xs[i])) { | ||
return i | ||
_arrayEach(function (x, i) { | ||
if (pred(x)) { | ||
_i = i | ||
return true | ||
} | ||
} | ||
return -1 | ||
}, xs) | ||
return _i | ||
}) | ||
/** | ||
* flatMap : (a -> b | [b]) -> [a] -> [b] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var flatMap = _curry2(function flatMap (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
, bs = [] | ||
, _i | ||
, b | ||
var flatMap = _curry2(function flatMap (fn, as) { | ||
var bs = [] | ||
for (; i < len; i++) { | ||
b = fn(xs[i]) | ||
if (Array.isArray(b)) { | ||
for (_i = 0; _i < b.length; _i++) { | ||
bs.push(b[_i]) | ||
} | ||
_arrayEach(function (a) { | ||
var x = fn(a) | ||
if (Array.isArray(x)) { | ||
_arrayEach(function (x_) { | ||
bs.push(x_) | ||
}, x) | ||
} else { | ||
bs.push(b) | ||
bs.push(x) | ||
} | ||
} | ||
}, as) | ||
@@ -325,76 +401,92 @@ return bs | ||
function _reduce (fn, b, as) { | ||
_arrayEach(function (a) { | ||
b = fn(b, a) | ||
}, as) | ||
return b | ||
} | ||
/** | ||
* reduce : ((b, a) -> b) -> b -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var flatten = function flatten (xs) { | ||
var i = 0 | ||
, len = xs.length | ||
, ys = [] | ||
, x | ||
, _i | ||
var reduce = _curry3(_reduce) | ||
for (; i < len; i++) { | ||
x = xs[i] | ||
if (Array.isArray(x)) { | ||
for (_i = 0; _i < x.length; _i++) { | ||
ys.push(x[_i]) | ||
} | ||
} else { | ||
ys.push(x) | ||
} | ||
/** | ||
* flatten : [[a]] -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var flatten = reduce(function flatten (acc, x) { | ||
if (Array.isArray(x)) { | ||
_arrayEach(function (x_) { | ||
acc.push(x_) | ||
}, x) | ||
} else { | ||
acc.push(x) | ||
} | ||
return acc | ||
}, []) | ||
return ys | ||
} | ||
/** | ||
* flattenDeep : [[a]] -> [a] | ||
* | ||
* @since v0.5.0 | ||
*/ | ||
var flattenDeep = function flattenDeep (xs) { | ||
var i = 0 | ||
, len = xs.length | ||
, ys = [] | ||
, x | ||
var _flattenDeep = reduce(function flattenDeep (acc, x) { | ||
return _concat.call( | ||
acc, | ||
Array.isArray(x) ? _flattenDeep(x) : x | ||
) | ||
}, []) | ||
for (; i < len; i++) { | ||
x = Array.isArray(xs[i]) ? flattenDeep(xs[i]) : xs[i] | ||
ys = ys.concat(x) | ||
} | ||
return ys | ||
/** | ||
* flip : (a -> b -> c -> ... -> z) -> (z -> ... -> c -> b -> a) | ||
* | ||
* @since v0.10.0 | ||
*/ | ||
function flip (fn) { | ||
return curryN(fn.length, function () { | ||
return fn.apply(this, _reverse.call(arguments)) | ||
}) | ||
} | ||
/** | ||
* forEach : (a -> *) -> [a] -> undefined | ||
* @since v0.1.0 | ||
*/ | ||
var forEach = _curry2(function forEach (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
for (; i < len; i++) { | ||
fn(xs[i]) | ||
} | ||
_arrayEach(function (x) { | ||
fn(x) | ||
}, xs) | ||
}) | ||
/** | ||
* fromPairs : [[k, v]] -> {k:v} | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var fromPairs = function fromPairs (xs) { | ||
var y = {} | ||
, i = 0 | ||
, len = xs.length | ||
, x | ||
var fromPairs = reduce(function fromPairs (acc, x) { | ||
acc[x[0]] = x[1] | ||
return acc | ||
}, {}) | ||
for (; i < len; i++) { | ||
x = xs[i] | ||
y[x[0]] = x[1] | ||
} | ||
var _hasOwn = Object.prototype.hasOwnProperty | ||
return y | ||
} | ||
/** | ||
* has : String -> {k:v} -> Boolean | ||
* | ||
* @since v0.11.0 | ||
*/ | ||
var has = _curry2(function as (k, o) { | ||
return _hasOwn.call(o, k) | ||
}) | ||
/** | ||
* head : [a] -> a | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var head = function head (xs) { | ||
function head (xs) { | ||
return xs[0] | ||
@@ -404,5 +496,7 @@ } | ||
/** | ||
* identity : a -> a | ||
* | ||
* @since v0.6.0 | ||
*/ | ||
var identity = function (a) { | ||
function identity (a) { | ||
return a | ||
@@ -412,5 +506,7 @@ } | ||
/** | ||
* inc : Number -> Number | ||
* | ||
* @since v0.6.0 | ||
*/ | ||
var inc = function inc (a) { | ||
function inc (a) { | ||
return a + 1 | ||
@@ -420,22 +516,45 @@ } | ||
/** | ||
* indexOf : a -> [a] -> Number | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var indexOf = _curry2(function indexOf (y, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
var _i = -1 | ||
for (; i < len; i++) { | ||
if (xs[i] === y) { | ||
return i | ||
_arrayEach(function (x, i) { | ||
if (x === y) { | ||
_i = i | ||
return true | ||
} | ||
} | ||
return -1 | ||
}, xs) | ||
return _i | ||
}) | ||
var keys = Object.keys | ||
/** | ||
* insert : Number -> a -> [a] -> [a] | ||
* | ||
* @since v0.11.0 | ||
*/ | ||
var insert = _curry3(function insert (idx, x, xs) { | ||
var ys = _slice(xs) | ||
ys[idx] = x | ||
return ys | ||
}) | ||
/** | ||
* keys : {k:v} -> [k] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var last = function last (xs) { | ||
function keys (object) { | ||
return Object.keys(object) | ||
} | ||
/** | ||
* last : [a] -> a | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
function last (xs) { | ||
return xs[xs.length - 1] | ||
@@ -469,13 +588,21 @@ } | ||
var map = _curry2(function map (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
, ys = new Array(len) | ||
var ys = new Array(xs.length) | ||
for (; i < len; i++) { | ||
ys[i] = fn(xs[i]) | ||
} | ||
_arrayEach(function (x, i) { | ||
ys[i] = fn(x) | ||
}, xs) | ||
return ys | ||
}) | ||
function _eachOwn (f, o) { | ||
for (var k in o) { | ||
if (_hasOwn.call(o, k)) { | ||
f(k, o[k]) | ||
} | ||
} | ||
} | ||
/** | ||
* merge : {k:v} -> {k:v} -> {k:v} | ||
* | ||
* Merges all own properties of the first object into the second. | ||
@@ -487,14 +614,8 @@ * | ||
var y = {} | ||
, prop | ||
, f = function (k, v) { | ||
y[k] = v | ||
} | ||
for (prop in b) { | ||
if (b.hasOwnProperty(prop)) { | ||
y[prop] = b[prop] | ||
} | ||
} | ||
for (prop in a) { | ||
if (a.hasOwnProperty(prop)) { | ||
y[prop] = a[prop] | ||
} | ||
} | ||
_eachOwn(f, b) | ||
_eachOwn(f, a) | ||
return y | ||
@@ -504,5 +625,7 @@ }) | ||
/** | ||
* not : Boolean -> Boolean | ||
* | ||
* @since v0.6.0 | ||
*/ | ||
var not = function not (a) { | ||
function not (a) { | ||
return !a | ||
@@ -512,5 +635,7 @@ } | ||
/** | ||
* of : a -> [a] | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var of = function of (x) { | ||
function of (x) { | ||
return [x] | ||
@@ -520,34 +645,22 @@ } | ||
/** | ||
* prop : String -> {k:v} -> v | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var pipe = function pipe () { | ||
var fns = arguments | ||
, len = fns.length | ||
return _curryN(fns[0].length, [], function __pipe__ () { | ||
var i = 0 | ||
, y = fns[i++].apply(null, arguments) | ||
for (; i < len; i++) { | ||
y = fns[i](y) | ||
} | ||
return y | ||
}) | ||
} | ||
/** | ||
* @since v0.1.0 | ||
*/ | ||
var prop = _curry2(function prop (p, x) { | ||
return x[p] | ||
var prop = _curry2(function prop (k, o) { | ||
return o[k] | ||
}) | ||
/** | ||
* propEq : String -> * -> {k:v} -> Boolean | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var propEq = _curry3(function propEq (p, y, x) { | ||
return x[p] === y | ||
var propEq = _curry3(function propEq (k, v, o) { | ||
return o[k] === v | ||
}) | ||
/** | ||
* rangeBy : Number -> Number -> Number -> [Number] | ||
* | ||
* @since v0.7.0 | ||
@@ -565,2 +678,4 @@ */ | ||
/** | ||
* range : Number -> [Number] | ||
* | ||
* @since v0.7.0 | ||
@@ -571,83 +686,73 @@ */ | ||
/** | ||
* reduceRight : ((b, a) -> b) -> b -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var reduce = _curry3(function reduce (fn, y, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
for (; i < len; i++) { | ||
y = fn(y, xs[i]) | ||
} | ||
return y | ||
}) | ||
/** | ||
* @since v0.1.0 | ||
*/ | ||
var reduceRight = _curry3(function reduceRight (fn, y, xs) { | ||
var i = xs.length - 1 | ||
for (; i >= 0; i--) { | ||
y = fn(y, xs[i]) | ||
} | ||
return y | ||
return _reduce(fn, y, _reverse.call(xs)) | ||
}) | ||
/** | ||
* reject : (a -> Boolean) -> [a] -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var reject = _curry2(function reject (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
, ys = [] | ||
, x | ||
for (; i < len; i++) { | ||
x = xs[i] | ||
if (!fn(x)) { | ||
ys.push(x) | ||
} | ||
} | ||
return ys | ||
return filter(complement(fn), xs) | ||
}) | ||
var _reverse = [].reverse | ||
/** | ||
* reverse : [a] -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var reverse = function reverse (xs) { | ||
return _reverse.call(xs.slice(0)) | ||
function reverse (xs) { | ||
return _reverse.call(_slice(xs, 0)) | ||
} | ||
/** | ||
* sum : [Number] -> Number | ||
* | ||
* @since v0.10.0 | ||
*/ | ||
var sum = reduce(add, 0) | ||
/** | ||
* tail : [a] -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var tail = function tail (xs) { | ||
return xs.slice(1) | ||
function tail (xs) { | ||
return _slice(xs, 1) | ||
} | ||
/** | ||
* take : Number -> [a] -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var take = _curry2(function take (n, xs) { | ||
return xs.slice(0, n) | ||
return _slice(xs, 0, n) | ||
}) | ||
/** | ||
* takeUntil : (a -> Boolean) -> [a] -> [a] | ||
* | ||
* @since v0.1.0 | ||
*/ | ||
var takeUntil = _curry2(function takeUntil (fn, xs) { | ||
var i = 0 | ||
, len = xs.length | ||
var ys | ||
for (; i < len; i++) { | ||
if (fn(xs[i])) { | ||
return xs.slice(0, i) | ||
_arrayEach(function (x, i) { | ||
if (fn(x)) { | ||
ys = _slice(xs, 0, i) | ||
return true | ||
} | ||
} | ||
return xs.slice(0) | ||
}, xs) | ||
return ys || _slice(xs) | ||
}) | ||
/** | ||
* times : (Number -> a) -> Number -> [a] | ||
* | ||
* @since v0.5.0 | ||
@@ -666,5 +771,7 @@ */ | ||
/** | ||
* toLower : String -> String | ||
* | ||
* @since v0.4.0 | ||
*/ | ||
var toLower = function toLower (a) { | ||
function toLower (a) { | ||
return a.toLowerCase() | ||
@@ -674,5 +781,7 @@ } | ||
/** | ||
* toUpper : String -> String | ||
* | ||
* @since v0.4.0 | ||
*/ | ||
var toUpper = function toUpper (a) { | ||
function toUpper (a) { | ||
return a.toUpperCase() | ||
@@ -682,6 +791,8 @@ } | ||
/** | ||
* tap : (a -> b) -> a -> a | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var tap = function (fn) { | ||
return function tapped (a) { | ||
function tap (fn) { | ||
return function (a) { | ||
fn(a) | ||
@@ -693,13 +804,12 @@ return a | ||
/** | ||
* toPairs : {k:v} -> [[k, v]] | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var toPairs = function toPairs (a) { | ||
var ys = [] | ||
, p | ||
function toPairs (o) { | ||
var kvs = [] | ||
for (p in a) { | ||
if (a.hasOwnProperty(p)) { | ||
ys.push([p, a[p]]) | ||
} | ||
} | ||
_eachOwn(function (k, v) { | ||
kvs.push([k, v]) | ||
}, o) | ||
return ys | ||
@@ -709,26 +819,21 @@ } | ||
/** | ||
* without : [a] -> [a] -> [a] | ||
* | ||
* @since v0.7.0 | ||
*/ | ||
var without = _curry2(function without (as, bs) { | ||
var ys = [] | ||
, bi = 0 | ||
, aslen = as.length | ||
, bslen = bs.length | ||
, ai | ||
, b | ||
, discard | ||
var ys = [] | ||
for (; bi < bslen; bi++) { | ||
b = bs[bi] | ||
discard = false | ||
for (ai = 0; ai < aslen; ai++) { | ||
if (b == as[ai]) { | ||
discard = true | ||
break | ||
_arrayEach(function (b) { | ||
var discard = false | ||
_arrayEach(function (a) { | ||
if (b === a) { | ||
return discard = true | ||
} | ||
} | ||
}, as) | ||
if (!discard) { | ||
ys.push(b) | ||
} | ||
} | ||
}, bs) | ||
return ys | ||
@@ -738,2 +843,4 @@ }) | ||
/** | ||
* zip : [a] -> [b] -> [[a, b]] | ||
* | ||
* @since v0.3.0 | ||
@@ -744,22 +851,24 @@ */ | ||
, len = Math.min(as.length, bs.length) | ||
, ys = new Array(len) | ||
, abs = new Array(len) | ||
for (; i < len; i++) { | ||
ys[i] = [as[i], bs[i]] | ||
abs[i] = [as[i], bs[i]] | ||
} | ||
return ys | ||
return abs | ||
}) | ||
/** | ||
* zipObj : [k] -> [v] -> {k:v} | ||
* | ||
* @since v0.3.0 | ||
*/ | ||
var zipObj = _curry2(function zipObj (keys, vals) { | ||
var zipObj = _curry2(function zipObj (ks, vs) { | ||
var i = 0 | ||
, len = Math.min(keys.length, vals.length) | ||
, res = {} | ||
, len = Math.min(ks.length, vs.length) | ||
, kv = {} | ||
for (; i < len; i++) { | ||
res[keys[i]] = vals[i] | ||
kv[ks[i]] = vs[i] | ||
} | ||
return res | ||
return kv | ||
}) | ||
@@ -771,2 +880,3 @@ | ||
exports.any = any; | ||
exports.append = append; | ||
exports.assoc = assoc; | ||
@@ -779,2 +889,4 @@ exports.concat = concat; | ||
exports.dec = dec; | ||
exports.dissoc = dissoc; | ||
exports.drop = drop; | ||
exports.equals = equals; | ||
@@ -786,5 +898,7 @@ exports.filter = filter; | ||
exports.flatten = flatten; | ||
exports.flattenDeep = flattenDeep; | ||
exports.flattenDeep = _flattenDeep; | ||
exports.flip = flip; | ||
exports.forEach = forEach; | ||
exports.fromPairs = fromPairs; | ||
exports.has = has; | ||
exports.head = head; | ||
@@ -794,2 +908,3 @@ exports.identity = identity; | ||
exports.indexOf = indexOf; | ||
exports.insert = insert; | ||
exports.keys = keys; | ||
@@ -812,2 +927,3 @@ exports.last = last; | ||
exports.reverse = reverse; | ||
exports.sum = sum; | ||
exports.tail = tail; | ||
@@ -814,0 +930,0 @@ exports.take = take; |
{ | ||
"name": "redash", | ||
"version": "0.9.0", | ||
"version": "0.10.4", | ||
"description": "", | ||
@@ -5,0 +5,0 @@ "main": "dist/redash.js", |
18673
807