Takes elements and fits them into subarrays (= batches) so that for each batch constrainedFunc returns true. Note that contrainedFunc should at least produce 1-length batches, otherwise an error is raised.

Returns the element equal to the given search value or undefined.

If defined, a converter function will be applied to compare an array element with the search value

If returnClosestElement is true, the element closest to the search value will be returned, even if it is not equal.

If false, only an exact match will be returned, otherwise undefined will be returned.

Removes all items. Mutating.

Returns a shallow copy of array.

Given a "listOfListsOfValues" in the form of an array of arrays, retrieve all the combinations by picking one item from each array. This basically creates a search tree, traverses it and gathers all node values whenever a leaf node is reached.

Can be used to recursively create all combinations of elements in n arrays. Given a "listOfListsOfValues" in the form of an array of arrays and pickIndices list with the size of the number of arrays which indicates what values to pick from each of the arrays. Returns a list with two lists:

1. values picked from each of the arrays, 2. the next pickIndices or null if at end (no more combinations possible). Needs to be called recursively to enumerate alls combinations.

// Example:
var searchSpace = [["a", "b", "c"], [1,2]];
arr.combinationsPick(searchSpace, [0,1]);
// => [["a",2], [1,0]]
arr.combinationsPick(searchSpace, [1,0]);
// => [["b",1], [1,1]]

Returns a copy of array with falsy values removed.

Returns the number of times item occurs in array.

Returns true if each element in array is structurally equal (lang.obj.equals) to its corresponding element in otherArray.

Iterates over array but instead of consecutively calling iterator, iterator gets passed in the invocation for the next iteration step as a function as first parameter. This allows to wait arbitrarily between operation steps, great for managing dependencies between tasks.

arr.doAndContinue([1,2,3,4], function(next, n) {
  alert("At " + n);
  setTimeout(next, 100);
}, function() { alert("Done"); })

If the elements are functions you can leave out the iterator:

arr.doAndContinue([
  function(next) { alert("At " + 1); next(); },
  function(next) { alert("At " + 2); next(); }
], null, function() { alert("Done"); });

Return elements from arr in a list starting from fun being falsy while iterating over arr.

Returns true if each element in array is equal (==) to its corresponding element in otherArray.

Returns only the Objects in arr that have key as property.

Find the first occurence for which iterator returns a truthy value and return this value, i.e. unlike find the iterator result and not the element of the list is returned.

Returns the first element of an array.

Creates an array with the result of generator called n times.

arr.genN(3, num.random) => [46,77,95]

Returns an array that contains all elements of arr that contain/satisfy test. grep stringifies all elements in arr.

Applies iterator to each element in array and puts the return value into a collection associated to its stringified representation.

// Example: Groups characters by how often they occur in a string
var chars = arr.from("Hello World");
arr.groupBy(arr.uniq(chars), function(c) {
return arr.count(chars, c); })
=> {
  "1": ["H","e"," ","W","r","d"],
  "2": ["o"],
  "3": ["l"]
}

When called without binspec, returns data partitioned into lists containing two elements each. binspec can be an array of n numbers. If given, histogram will create n-1 bins, using the provided values in binspec as threshholds. The n-1 bins will be returned as a list. T

/** Returns a new array that contains an element of arra and delim alternating.

Rerturns the intersection of array1 and array2 according to set semantic.

Calls method on each element in array, passing all arguments. Often a handy way to avoid verbose map calls.

Returns a boolean indicating whether or not array is sorted.

Returns wether all elements in list1 are in list2.

Returns the last element of an array.

Return an array containing all elements or array for which mask contains a truthy value at the same index.

Return the element of array which has the highest value according to iterator.

Return the element of array which has the smallest value according to iterator.

Returns array with falsy values removed.

Calls iterator for every element in array and waits between iterator calls waitSecs. Eventually endFunc is called. When passing a number n as optSynchronChunks, only every nth iteration is delayed.

Partition array according to a condition specified in iterator. Creates two partitions (condition is either true or false).

Returns the number of permutations of the elements in array.

Returns property or undefined from each element of array. For quick maps and similar to invoke.

Appends all items to array. Mutating.

Inserts all items at idx. Mutating.

Inserts item at index. Mutating.

Only appends item if its not already in array. Mutating.

Creates an array containing elements from begin until end with step-sized steps.

Returns an array of all elements of array for which func is falsy.

Returns an array of all elements of array that do not have key as property.

Returns the matches of re for the elements in arr. Might include null items if re did not match.

Removes the first occurrence of item in array. Mutating.

Remove the element of array at index. Mutating.

Replace the element array[index] with item. Mutating.

Shift the elements in array to the left times times.

Randomizes the order of elements in array. Non-mutating.

Sorts array according to the elements value of iterator.

Sorts array by the values of a given key.

Return the sum of the elements of array.

Swap the element at array[index1] with the one at array[index2]. Mutating.

Return elements from arr in a list until fun is falsy while iterating over arr.

Decomposes array into sub-arrays with at most tupleLength elements.

Rerturns the union of array1 and array2 according to set semantic.

Returns array without duplicates.

Like arr.uniq but with custom equality comparator(a,b).

Like arr.uniq but with equality based on array[index].key.

Returns an array filled with obj for n times.

Returns a copy of array without elem.

Returns a copy of array without all elements in otherArr.

Takes any number of lists as arguments. Combines them elment-wise.

arr.zip([1,2,3], ["a", "b", "c"], ["A", "B"])
=> [[1,"a","A"],[2,"b","B"],[3,"c",undefined]]