list

List operations module.

Methods

static all(p, xs) → {Boolean}

Returns true if all items in container pass predicate `p`.
Parameters:
Name Type Description
p function Predicate.
xs Array | String
Returns:
Boolean

static and(xs) → {Boolean}

Conjuction of container of bools (or truthy and/or falsy values); Returns `true` if all in container are 'truthy' else returns `false`
Parameters:
Name Type Description
xs Array | String
Returns:
Boolean

static any(p, xs) → {Boolean}

Returns true if any item in container passes predicate `p`.
Parameters:
Name Type Description
p function Predicate.
xs Array | String
Returns:
Boolean

static append(…argsopt) → {Array|String|*}

Append two, or more, lists, i.e.,
Parameters:
Name Type Attributes Description
args Array | String | * <optional>
<repeatable>
One or more lists or list likes (strings etc.).
Returns:
Array | String | * - - Same type as list like passed in.
Example
expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true

// Another example
const result = append(
  alphabetStr.split(''),
  alphabetStr.split('')
),
expected = repeat(2, alphabetStr).split('');

shallowEquals(result, expected) === true // `true`

static at(ind, xs) → {*|undefined}

Gets item at index.
Parameters:
Name Type Description
ind Number Index.
xs Array list or list like.
Returns:
* | undefined - - Item or `undefined`.

static breakOnList(pred, list) → {Array}

breakOnList, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p and second element is the remainder of the list:
Parameters:
Name Type Description
pred function
list Array | String | *
Returns:
Array

static complement(arr0, …arrays) → {Array}

Returns the complement of list 0 and the reset of the passed in arrays.
Parameters:
Name Type Attributes Description
arr0 Array
arrays Array <repeatable>
Returns:
Array

static concat(xs) → {Array}

Concatenates all the elements of a container of lists.
Parameters:
Name Type Description
xs Array
Returns:
Array

static concatMap(fn, foldableOfA) → {Array}

Map a function over all the elements of a container and concatenate the resulting lists.
Parameters:
Name Type Description
fn function
foldableOfA Array
Returns:
Array

static cycle(limit, xs) → {Array}

Replicates a list `limit` number of times and appends the results (concat)
Parameters:
Name Type Description
limit Number
xs Array
Returns:
Array

static difference(array1, array2) → {Array}

Returns the difference of list 1 from list 2.
Parameters:
Name Type Description
array1 Array
array2 Array
Returns:
Array

static drop(list, count) → {String|Array}

Drops `n` items from start of list to `count` (exclusive).
Parameters:
Name Type Description
list Array | String
count Number
Returns:
String | Array - - Passed in type's type

static dropWhile(pred, list) → {Array|String}

Returns an list without elements that match predicate.
Parameters:
Name Type Description
pred function Predicate<*, index, list|string>
list Array | String
Returns:
Array | String

static dropWhileEnd(pred, list) → {Array|String}

Parameters:
Name Type Description
pred function Predicate<*, index, list|string>
list Array | String
Returns:
Array | String

static elem(element, xs) → {Boolean}

Returns a boolean indicating whether an element exists in given structure of elements.
Parameters:
Name Type Description
element *
xs Array
Returns:
Boolean

static elemIndex(x, xs) → {*}

Parameters:
Name Type Description
x * Element to search for.
xs Array list or list like.
Returns:
*

static elemIndices(value, xs) → {*}

Parameters:
Name Type Description
value * Element to search for.
xs Array list or list like.
Returns:
*

static filter(pred, xs) → {Array}

Filters a structure of elements using given predicate (`pred`) (same as `[].filter`).
Parameters:
Name Type Description
pred function
xs Array list or list like.
Returns:
Array - - Structure of filtered elements.

static find(pred, xs) → {*}

Find an item in structure of elements based on given predicate (`pred`).
Parameters:
Name Type Description
pred function
xs Array list or list like.
Returns:
* - - Found item.

static findIndex(pred, arr) → {Number}

Finds index in string or list (alias for `findIndex`).
Parameters:
Name Type Description
pred function Predicate.
arr Array | String
Returns:
Number - - `-1` if predicate not matched else `index` found

static findIndices(pred, xs) → {Array|undefined}

Parameters:
Name Type Description
pred function
xs Array list or list like.
Returns:
Array | undefined

static foldl(fn, zero, functor) → {*}

Left associative fold. Reduces a container of elements down by the given operation (same as [].reduce).
Parameters:
Name Type Description
fn function
zero * Aggregator.
functor Array
Returns:
* - - Whatever type is lastly returned from `fn`.

static foldl1(op, xs) → {*}

A variant of `foldl` except that this one doesn't require the starting point. The starting point/value will be pulled out from a copy of the container.
Parameters:
Name Type Description
op function
xs Array
Returns:
* - - Whatever type is lastly returned from `op`.

static foldr(fn, zero, functor) → {*}

Right associative fold. Reduces a container of elements down by the given operation (same as [].reduceRight).
Parameters:
Name Type Description
fn function
zero * Aggregator.
functor Array
Returns:
* - - Whatever type is lastly returned from `fn`.

static foldr1(op, xs) → {*}

A variant of `foldr` except that this one doesn't require the starting point/value. The starting point/value will be pulled out from a copy of the container.
Parameters:
Name Type Description
op function
xs Array
Returns:
* - - Whatever type is lastly returned from `op`.

static forEach(fn, xs) → {void}

For each function (same as `[].forEach` except in functional format).
Parameters:
Name Type Description
fn function Operation (`(element, index, list) => {...}`, etc.)
xs Array | String
Returns:
void

static group(xs) → {Array.<(Array|String|*)>|*}

The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example, `group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]` It is a special case of groupBy, which allows the programmer to supply their own equality test.
Parameters:
Name Type Description
xs Array | String
Returns:
Array.<(Array|String|*)> | *

static groupBy(equalityOp, xs) → {*}

Allows you to group items in a list based on your supplied equality check.
Parameters:
Name Type Description
equalityOp function
xs Array
Returns:
*

static head(x) → {*}

Returns head of list (first item of list).
Parameters:
Name Type Description
x Array | String
Returns:
* - - First item from list

static includes(value, xs) → {Boolean}

`Array.prototype.includes` or shim.
Parameters:
Name Type Description
value *
xs Array | String
Returns:
Boolean

static indexOf(x, xs) → {Number}

Searches list/list-like for given element `x`.
Parameters:
Name Type Description
x * Element to search for.
xs Array | String | * list or list like to look in.
Returns:
Number - - `-1` if element not found else index at which it is found.

static init(xs) → {Array|String}

Returns everything except last item of list as new list.
Parameters:
Name Type Description
xs Array | String
Returns:
Array | String

static inits(xs) → {Array}

The inits function returns all initial segments of the argument, shortest first. For example, ``` shallowEquals(inits('abc'), ['','a','ab','abc']) ```
Parameters:
Name Type Description
xs Array
Returns:
Array

static insert(x, xs) → {Array}

The insert function takes an element and a list and inserts the element into the list at the first position where it is less than or equal to the next element. In particular, if the list is sorted before the call, the result will also be sorted. It is a special case of insertBy, which allows the programmer to supply their own comparison function.
Parameters:
Name Type Description
x *
xs Array | *
Returns:
Array

static insertBy(orderingFn, x, xs) → {Array}

A version of `insert` that allows you to specify the ordering of the inserted item; Before/at, or after
Parameters:
Name Type Description
orderingFn function A function that returns `-1`, `0`, or 1`.
x * Value to insert.
xs Array List to insert into (note new list is returned)
Returns:
Array - - New list.

static intercalate(xs, xss) → {Array|String}

`intercalate xs xss` is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.
Parameters:
Name Type Description
xs Array | String
xss Array | String
Returns:
Array | String

static intersect(arr1, arr2) → {Array}

Performs an intersection on list 1 with elements from list 2.
Parameters:
Name Type Description
arr1 Array
arr2 Array
Returns:
Array

static intersectBy(pred, list1, list2) → {Array}

Returns an intersection by predicate.
Parameters:
Name Type Description
pred function `pred :: a -> b -> Bool`
list1 Array
list2 Array
Returns:
Array

static intersperse(between, arr) → {Array|String}

Takes an element and a list and `intersperses' that element between the elements of the list.
Parameters:
Name Type Description
between * Should be of the same type of elements contained in list.
arr Array | String List.
Returns:
Array | String

static isInfixOf(xs1, xs2) → {boolean}

Checks if list `xs1` is an infix of list `xs2`
Parameters:
Name Type Description
xs1 Array | String | *
xs2 Array | String | *
Returns:
boolean

static isPrefixOf(xs1, xs2) → {boolean}

Checks if list `xs1` is a prefix of list `xs2`
Parameters:
Name Type Description
xs1 Array | String | *
xs2 Array | String | *
Returns:
boolean

static isSubsequenceOf(xs1, xs2) → {boolean}

Checks if list `xs1` is a sub-sequence of list `xs2`
Parameters:
Name Type Description
xs1 Array | String | *
xs2 Array | String | *
Returns:
boolean

static isSuffixOf(xs1, xs2) → {boolean}

Checks if list `xs1` is a suffix of list `xs2`
Parameters:
Name Type Description
xs1 Array | String | *
xs2 Array | String | *
Returns:
boolean

static iterate(limit, op, x) → {*}

iterate f x returns an infinite list of repeated applications of f to x.
Parameters:
Name Type Description
limit Number
op function Operation.
x * Starting point.
Returns:
*
Example
`iterate(5, f, x) == [x, f(x), f(f(x)), ...]`

static last(xs) → {*}

Returns last item of list.
Parameters:
Name Type Description
xs Array | String
Returns:
*

static lastIndexOf(x, xs) → {Number}

Last index of (`Array.prototype.lastIndexOf`).
Parameters:
Name Type Description
x * Element to search for.
xs Array | String | * list or list like to look in.
Returns:
Number - - `-1` if element not found else index at which it is found.

static map(fn, xs) → {Array|String|*}

Maps a function onto a List (string or array) or a functor (value containing a map method).
Parameters:
Name Type Description
fn function Function to map on given value.
xs Array | String | *
Returns:
Array | String | *

static mapAccumL(op, zero, xs) → {Array}

Performs a map then a reduce all in one (from left-to-right). Returns a tuple containing the aggregated value and the result of mapping the passed in function on passed in list.
Parameters:
Name Type Description
op function Function : [aggregated, mapResult]
zero * An instance of the passed in list type used to aggregateArray on.
xs Array list type.
Returns:
Array - - [aggregated, list]

static mapAccumR(op, zero, xs) → {Array}

Performs a map and a reduce all in one (from right-to-left). Returns a tuple containing the aggregated value and the result of mapping the passed in function on passed in list.
Parameters:
Name Type Description
op function Function : [aggregated, mapResult]
zero * An instance of the passed in list type used to aggregateArray on.
xs Array list type.
Returns:
Array - - [aggregated, list]

static maximum(list) → {*}

Returns the largest element in a non-empty structure of elements.
Parameters:
Name Type Description
list Array | String
Returns:
* - - Whatever type the array is made of (if any).

static minimum(list) → {*}

Returns the smallest element in a non-empty structure of elements.
Parameters:
Name Type Description
list Array | String
Returns:
* - - Whatever type the array is made of (if any).

static not(xs) → {Boolean}

Returns a boolean indicating whether all items in container are 'falsy' or not. **Note** The haskell type for this function only takes two items, but here we allow the passing of more than one item (may change later to adhere to the haskell type).
Parameters:
Name Type Description
xs Array | String
Returns:
Boolean

static notElem(element, xs) → {Boolean}

The opposite of `elem` - Returns a boolean indicating whether an element exists in given list.
Parameters:
Name Type Description
element *
xs Array
Returns:
Boolean

static nub(list) → {Array}

The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means `essence'.) It is a special case of nubBy, which allows the programmer to supply their own equality test. ```shallowCompare( nub ([1,2,3,4,3,2,1,2,4,3,5]), [1,2,3,4,5] )```
Parameters:
Name Type Description
list Array | String | *
Returns:
Array

static nubBy(pred, list) → {Array}

The nubBy function behaves just like nub, except it uses a user-supplied equality predicate.
Parameters:
Name Type Description
pred function
list Array | String | *
Returns:
Array

static or(xs) → {Boolean}

Returns a boolean indicating whether any item in container is 'truthy' or not. **Note** The haskell type for this function only takes two items, but here we allow the passing of more than one item (may change later to adhere to the haskell type).
Parameters:
Name Type Description
xs Array | String
Returns:
Boolean

static partition(pred, list) → {Array|String}

Partitions a list on a predicate; Items that match predicate are in first list in tuple; Items that do not match the tuple are in second list in the returned tuple. Essentially `[filter(p, xs), filter(negateF3(p), xs)]`.
Parameters:
Name Type Description
pred function Predicate
list Array
Returns:
Array | String - - Tuple of arrays or strings (depends on incoming list (of type list or string)).

static permutations(xs) → {Array.<(Array|String|*)>}

Returns a list of permutations for passed in list. Use caution with lists above a length of 15 (will take long due to nature of algorithm).
Parameters:
Name Type Description
xs Array List.
Returns:
Array.<(Array|String|*)> - - Array of permutations.

static product(list) → {Number}

Computes the product of the numbers of a structure.
Parameters:
Name Type Description
list Array | String
Returns:
Number

static range(from, to, stepopt) → {Array.<Number>}

Range function - gives you an array contain numbers in given range.
Parameters:
Name Type Attributes Default Description
from Number
to Number
step Number <optional>
1
Returns:
Array.<Number>

static remove(x, list) → {Array}

`remove(x, xs)` removes the first occurrence of `x` from `xs`. For example, `remove('a', 'banana') === 'bnana';`
Parameters:
Name Type Description
x *
list Array | String | *
Returns:
Array

static removeBy(pred, x, list) → {Array}

Behaves the same as `remove`, but takes a user-supplied equality predicate.
Parameters:
Name Type Description
pred function Equality predicate `(a, b) => bool`
x *
list Array | String | *
Returns:
Array

static removeFirstBy(pred, xs1, xs2) → {Array}

The `removeFirstsBy` function takes a predicate and two lists and returns the first list with the first occurrence of each element of the second list removed.
Parameters:
Name Type Description
pred function
xs1 Array | String | *
xs2 Array | String | *
Returns:
Array

static repeat(limit, x) → {Array}

Repeats `x` `limit` number of times.
Parameters:
Name Type Description
limit Number
x *
Returns:
Array

static replicate(limit, x) → {Array}

Same as `repeat` due to the nature of javascript (see haskell version for usage).
Parameters:
Name Type Description
limit Number
x *
Returns:
Array

static reverse(xs) → {Array|String}

Returns a copy of the passed in list reverses.
Parameters:
Name Type Description
xs Array | String
Returns:
Array | String

static scanl(fn, zero, xs) → {Array|*}

scanl is similar to foldl, but returns a list of successive reduced values from the left: ``` scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] ``` Also note that: ``` last (scanl f z xs) == foldl f z xs. ```
Parameters:
Name Type Description
fn function
zero *
xs Array
Returns:
Array | *

static scanl1(fn, xs) → {Array|*}

`scanl1` is a variant of `scanl` that has no starting value argument: `shallowCompare(scanl1(fn, [x1, x2, ...]), [x1, fn(x1, x2), ...]) // true`
Parameters:
Name Type Description
fn function
xs Array
Returns:
Array | *

static scanr(fn, zero, xs) → {Array|*}

Same as `scanl` but from the right (similiar to `foldr`'s relationship to 'foldl'). Note also `scanr`'s relationship ot `foldr`: `head (scanr(fn, z, xs)) === foldr(fn, z, xs).
Parameters:
Name Type Description
fn function
zero *
xs Array
Returns:
Array | *

static scanr1(fn, xs) → {Array|*}

Same as `scanr` but takes no zero/accumulator value.
Parameters:
Name Type Description
fn function
xs Array
Returns:
Array | *

static slice(separator, arr) → {Array}

Same as Array.prototype.slice
Parameters:
Name Type Description
separator String | RegExp
arr Array
Returns:
Array

static sort(xs) → {Array}

The sort function implements a stable sorting algorithm. It is a special case of sortBy, which allows the programmer to supply their own comparison function. ```shallowCompare(sort ([1,6,4,3,2,5]), [1,2,3,4,5,6]) // true```
Parameters:
Name Type Description
xs Array | String | *
Returns:
Array

static sortBy(orderingFn, xs) → {Array|String|*}

The sortBy function is the non-overloaded (in haskell terms) version of sort.
Parameters:
Name Type Description
orderingFn function
xs Array | String | *
Returns:
Array | String | *

static sortOn(valueFn, xs) → {Array}

Sort a list by comparing the results of a key function applied to each element. sortOn f is equivalent to sortBy (comparing f), but has the performance advantage of only evaluating f once for each element in the input list. This is called the decorate-sort-undecorate paradigm, or Schwartzian transform. Elements are arranged from from lowest to highest, keeping duplicates in the order they appeared in the input. Ex: ``` shallowEquals( sortOn (head, [[2, "world"], [4, "!"], [1, "Hello"]]), [[1,"Hello"],[2,"world"],[4,"!"]] ) // true ```
Parameters:
Name Type Description
valueFn function
xs Array | String | *
Returns:
Array

static splitAt(ind, list) → {Array|String}

Splits `x` in two at given `index` (exclusive (includes element/character at given index in second part of returned list)).
Parameters:
Name Type Description
ind Number Index to split at.
list Array | String functor (list or string) to split.
Returns:
Array | String - - List like type passed

static stripPrefix(prefix, list) → {Array|*}

Strips prefix list from given list
Parameters:
Name Type Description
prefix Array | String | *
list Array | string | *
Returns:
Array | *

static subsequences(xs) → {Array.<Array>}

Generates 2^n sub-sequences for passed in sequence (string/list) (`n` is the length of the passed in sequence so: 2^length(xs)). Note: The return value doubles per index/character passed in so use with caution! Also note that for 2^16 (or for a sequence of 16 characters) this algorithm will generate 65536 sub-sequences! So caution should be taken to not use this with sequences above a certain length on certain platform (the browser thread in specific).
Parameters:
Name Type Description
xs Array | String
Returns:
Array.<Array>

static sum(list) → {Number}

Computes the sum of the numbers of a structure.
Parameters:
Name Type Description
list Array | String
Returns:
Number

static swapped(ind1, ind2, list) → {Array}

Returns an array with the given indices swapped.
Parameters:
Name Type Description
ind1 Number
ind2 Number
list Array
Returns:
Array - - Copy of incoming with swapped values at indices.

static tail(xs) → {Array|String}

Returns tail part of list (everything after the first item as new list).
Parameters:
Name Type Description
xs Array | String
Returns:
Array | String

static tails(xs) → {Array}

The inits function returns all initial segments of the argument, shortest first. For example, ``` shallowEquals(tails('abc'), ['abc', 'bc', 'c','']) ```
Parameters:
Name Type Description
xs Array
Returns:
Array

static take(list, limit) → {String|Array}

Takes `n` items from start of list to `limit` (exclusive).
Parameters:
Name Type Description
list Array | String
limit Number
Returns:
String | Array - - Passed in type's type

static takeWhile(pred, list) → {Array}

Gives an list with passed elements while predicate was true.
Parameters:
Name Type Description
pred function Predicate<*, index, list|string>
list Array | String
Returns:
Array

static transpose(xss) → {Array}

Transposes rows and columns into lists by index; E.g., Haskell example: ``` transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]] -- Notice the shorter arrays are ignored after their last index is copied over: transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]] ```
Parameters:
Name Type Description
xss Array
Returns:
Array

static uncons(xs) → {Array|undefined}

Returns `head` and `tail` of passed in list/string in a tuple.
Parameters:
Name Type Description
xs Array | String
Returns:
Array | undefined

static unconsr(xs) → {Array|String|*|undefined}

Returns `tail` and `head` of passed in list/string in a tuple.
Parameters:
Name Type Description
xs Array | String
Returns:
Array | String | * | undefined

static unfoldr(op, x) → {Array}

Unfolds a value into a list of somethings.
Parameters:
Name Type Description
op function Operation to perform (should return a two component tuple (item to aggregateArray and item to unfold in next iteration).
x * Starting parameter to unfold from.
Returns:
Array - - An array of whatever you return from `op` yielded.

static union(arr1, arr2) → {Array}

Creates a union on matching elements from array1.
Parameters:
Name Type Description
arr1 Array
arr2 Array
Returns:
Array

static unionBy(pred, arr1, arr2) → {Array}

Returns the union on elements matching boolean check passed in.
Parameters:
Name Type Description
pred function `pred :: a -> a -> Bool`
arr1 Array
arr2 Array
Returns:
Array

static unzip(arr) → {Array|*}

unzip transforms a list of pairs into a list of first components and a list of second components.
Parameters:
Name Type Description
arr Array | *
Returns:
Array | *

static unzipN(list) → {Array|*}

unzip transforms a list of pairs into a list of first components and a list of second components.
Parameters:
Name Type Description
list Array | * List of tuples (lists).
Returns:
Array | *

static zip(arr1, arr2) → {Array.<Array.<*, *>>}

zip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded.
Parameters:
Name Type Description
arr1 Array
arr2 Array
Returns:
Array.<Array.<*, *>>

static zip3(arr1, arr2, arr3) → {Array.<Array.<*, *>>}

Parameters:
Name Type Description
arr1 Array
arr2 Array
arr3 Array
Returns:
Array.<Array.<*, *>>

static zip4(arr1, arr2, arr3, arr4) → {Array.<Array.<*, *>>}

Parameters:
Name Type Description
arr1 Array
arr2 Array
arr3 Array
arr4 Array
Returns:
Array.<Array.<*, *>>

static zip5(arr1, arr2, arr3, arr4, arr5) → {Array.<Array.<*, *>>}

Parameters:
Name Type Description
arr1 Array
arr2 Array
arr3 Array
arr4 Array
arr5 Array
Returns:
Array.<Array.<*, *>>

static zipN(lists) → {Array}

zipN takes one or more lists and returns a list containing lists of all indices at a given index, index by index. If one input list is short, excess elements of the longer list are discarded.
Parameters:
Name Type Description
lists Array | String One ore more lists of the same type.
Returns:
Array

static zipWith(op, xs1, xs2) → {Array.<Array.<*, *>>}

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] zipWith generalises zip by zipping with the function given as the first argument, instead of a function tupling function (function that returns a tuple). For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.
Parameters:
Name Type Description
op function Takes two parts of a tuple and returns a tuple. E.g., ` op :: a -> b -> (a, b)`
xs1 Array
xs2 Array
Returns:
Array.<Array.<*, *>>
Example
```
zipWith f [] _|_ = []
```

static zipWith3(op, xs1, xs2, xs3) → {Array.<Array.<*, *>>}

Zips 3 lists with tupling function.
Parameters:
Name Type Description
op function Takes expected number of parts for tuple and returns a tuple of said parts: E.g., ` op :: a -> b -> c -> (a, b, c)`
xs1 Array
xs2 Array
xs3 Array
Returns:
Array.<Array.<*, *>>

static zipWith4(op, xs1, xs2, xs3, xs4) → {Array.<Array.<*, *>>}

Zips 4 lists with tupling function.
Parameters:
Name Type Description
op function Takes expected number of parts for tuple and returns a tuple of said parts: E.g., ` op :: a -> b -> c -> d -> (a, b, c, d)`
xs1 Array
xs2 Array
xs3 Array
xs4 Array
Returns:
Array.<Array.<*, *>>

static zipWith5(op, xs1, xs2, xs3, xs4, xs5) → {Array.<Array.<*, *>>}

Zips 5 lists.
Parameters:
Name Type Description
op function Takes expected number of parts for tuple and returns a tuple of said parts: E.g., ` op :: a -> b -> c -> d -> e -> (a, b, c, d, e)`
xs1 Array
xs2 Array
xs3 Array
xs4 Array
xs5 Array
Returns:
Array.<Array.<*, *>>

static zipWithN(op, lists) → {Array.<Array.<*, *>>}

Zips all given lists with tupling function. Note: Haskell types do not have a way (that I know of) to show one or more for params in a function so `@haskellType` below is left there for general purpose not for exactness as is told by aforementioned.
Parameters:
Name Type Description
op function Takes expected number of parts for tuple and returns a tuple of said parts: E.g., ` op :: a -> b -> c -> (a, b, c)`
lists Array ...
Returns:
Array.<Array.<*, *>>