❤
npm
Sign UpSign In

lists

0.2.15 • Public • Published

[ l [ i [ s ] t ] s ]

Full Version | Homepage

Lists is a library of JavaScript higher-order functions for working with arrays and strings. The library was inspired by Haskell's Data.List module by the powerful people over at The University of Glasgow. You can view the original source here. You could then scroll through each function closely and see a purposefully similar correlation between the Haskell implementation and this implementation.

Pass functions to functions to functions to solve complex problems. Most of the functions featured in Lists produce new arrays, to reinforce the paradigm of stateless programming.

Disclaimer: Almost all of these functions are naive recursive definitions. The idea behind this library is to maximize problem-solving expressivity. This library provides an alternative toolbox by which to solve problems. This library should be sufficient for most projects but remember to monitor your heap memory space in the case of excessive function calls.

Install

To import the entire library:

npm install --save lists

Using in your Node.js project:

var lists = require('lists');

Using in your browser:

Download the script source file lists.min.js and include it in your HTML. Lists is exported as a global object attached to window. Access functions by calling lists or window.lists.

<script src='lists.min.js'></script>
<script>
    lists.head(["Hey!"]); // "Hey!"
</script> 

Practical Example Usage

Lets complete an easy task from /r/dailyprogrammer. Here is the task:

Given a NxN size 2D array of numbers. Develop a way to rotate the data as if you rotated the data by 90 degrees clockwise.

The challenge input is a 10x10 matrix that looks like this:

var matrix = 
[[1,2,3,4,5,6,7,8,9,0],
 [0,9,8,7,6,5,4,3,2,1],
 [1,3,5,7,9,2,4,6,8,0],
 [0,8,6,4,2,9,7,5,3,1],
 [0,1,2,3,4,5,4,3,2,1],
 [9,8,7,6,5,6,7,8,9,0],
 [1,1,1,1,1,1,1,1,1,1],
 [2,2,2,2,2,2,2,2,2,2],
 [9,8,7,6,7,8,9,8,7,6],
 [0,0,0,0,0,0,0,0,0,0]];

Using Lists, we can reverse and then transpose this matrix to achieve the desired output:

var l = require('lists');
l.transpose(l.rev(matrix));
 
// or using pipe (composing left)
var rotate90 = l.pipe(l.transpose, l.rev);
rotate90(matrix);
 
/* both of these functions yield
[[0,9,2,1,9,0,0,1,0,1], 
 [0,8,2,1,8,1,8,3,9,2], 
 [0,7,2,1,7,2,6,5,8,3], 
 [0,6,2,1,6,3,4,7,7,4], 
 [0,7,2,1,5,4,2,9,6,5], 
 [0,8,2,1,6,5,9,2,5,6],
 [0,9,2,1,7,4,7,4,4,7], 
 [0,8,2,1,8,3,5,6,3,8],
 [0,7,2,1,9,2,3,8,2,9], 
 [0,6,2,1,0,1,1,0,1,0]];
/*

Type Signature Legend

  • arr | [] : Array
  • obj | {} : Object
  • str : String
  • num : Number
  • f : Function
  • x : Variable
  • boolean : boolean

A{ 1. } Function number

B{ tail } Function name

C{ [x]|str -> [x] } Pseudo type signature

tail : [x]|str -> [x]

  • Takes an Array of Variables or a String and produces an Array of Variables ([x]).

map : [x] -> f -> [x]

  • Takes an Array of Variables and a Function and produces an Array of Variables.

Contents

Basic Functions

  • append : [x]|str -> [x]|str|num -> [x]|str
  • head : [x]|str -> x
  • last : [x]|str -> x
  • init : [x]|str -> [x]
  • tail : [x]|str -> [x]
  • nil : [x]|str -> boolean

List Transformations

Reducing Lists (folds)

Building Lists

  • scanl : x -> [x]|str -> f -> [x]
  • scanr : x -> [x]|str -> f -> [x]
  • mapAccumL : x -> [x]|str -> f -> [x, [x]]
  • mapAccumR : x -> [x]|str -> f -> [x, [x]]
  • iterate : x -> num -> f -> [x]
  • replicate : x -> num -> [x]
  • cycle : [x]|str -> num -> [x]|str
  • unfold : f -> f -> f -> x -> [x]|str

Sublists

  • take : num -> [x]|str -> [x]
  • drop : num -> [x]|str -> [x]
  • splitAt : num -> [x]|str -> [[x],[x]]
  • takeWhile : f -> [x]|str -> [x]
  • dropWhile : f -> [x]|str -> [x]
  • span : [x]|str -> f -> [[x], [x]|str]
  • break : [x]|str -> f -> [[x], [x]|str]
  • stripPrefix : [num]|str -> [num]|str -> [num]|[str]
  • group : [num]|str -> [[num]]|[[str]]
  • inits : [x]|str -> [[x]]
  • tails : [x]|str -> [[x]]

Predicates

Searching Lists

  • elem : num|str -> [num]|str -> boolean
  • notElem : num|str -> [num]|str -> boolean
  • lookup : num|str -> [[num|str,x]] -> boolean
  • find : [x]|str -> f -> x
  • filter : [x]|str -> f -> [x]
  • partition : [x]|str -> f -> [[x],[x]]

Indexing Lists

Zipping and Unzipping Lists

  • zip || unzip : [[a,b,..,n],[c,d,..,n],..,n] -> [[a,c,..,n],[b,d,..,n],..,n]
  • zipWith : [[a,b,..,n],[c,d,..,n],..,n] -> f -> [x]

Special Lists

Generalized Functions

Extra Functional Utilities

append : [x]|str -> [x]|str|num -> [x]|str

Description: A prefix-style Array.prototype.concat wrapper.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 an Array of Variables or a String or a Number. Get an Array of Variables or a String.

Example Usage:

lists.append([1],[2]); /* [1,2] */ 
lists.append([1],2); /* [1,2] */ 
lists.append('a','b'); /* 'ab' */

head : [x]|str -> x

Description: Retreive the first element of an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Get a Variable.

Example Usage:

lists.head([1,2]); /* 1 */ 
lists.head([[1,2],[3,4]]); /* [1,2]  */ 
lists.head('ab'); /* 'a' */

last : [x]|str -> x

Description: Retreive the last element of an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Get a Variable.

Example Usage:

lists.last([1,2]); /* 2 */ 
lists.last([[1,2],[3,4]]); /* [3,4] */ 
lists.last('ab'); /* 'b' */

init : [x]|str -> [x]

Description: Retreive all elements except the last of an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.init([1,2,3]); /* [1,2] */ 
lists.init([[1,2],[3,4],[5,6]]); /* [[1,2],[3,4]]  */ 
lists.init('abc'); /* ['a','b'] */

tail : [x]|str -> [x]

Description: Retreive all elements except the first of an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.tail([1,2,3]); /* [2,3] */ 
lists.tail([[1,2],[3,4],[5,6]]); /* [[3,4],[5,6]]  */ 
lists.tail('abc'); /* ['b','c'] */

nil : [x]|str -> boolean

Description: Test if an Array of Variables or a String is empty.

Signature Definition: Give arg 1 an Array of Variables or a String; Get a boolean.

Example Usage:

lists.nil(null); /* true */ 
lists.nil([]); /* true */ 
lists.nil(''); /* true */ 
lists.nil('a'); /* false */ 
lists.nil([1]); /* false */

map : [x]|str -> f -> [x]

Description: Array of Variables returned by applying f to each element of an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of Variables.

Example Usage:

lists.map([1,2,3], function(x) { return x*2 }); /* [2,4,6] */
lists.map('abc', function(str) { return str.toUpperCase() }); /* ["A","B","C"] */
lists.map([{'S': 1}, {'u': 2}, {'p': 3}], function(obj) {
  return lists.flatten(lists.keys(obj))
}); /* ["S", "u", "p"] */

rev : [x]|str -> [x]

Description: Array of Variables returned by reversing the order of each element of an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.rev([1,2,3]); /* [3,2,1] */
lists.rev('abc'); /* ['c','b','a'] */
lists.rev([[2],[3]]); /* [[3],[2]] */

intersperse : x -> [x]|str -> [x]|str

Description: Array of Variables or a String returned by interspersing a given separator between elements of a given Array.

Signature Definition: Give arg 1 a Variable. Give arg 2 an Array of Variables or a String. Get an Array of Variables or a String.

Example Usage:

lists.intersperse(1,[5,5,5]); /* [5,1,5,1,5] */
lists.intersperse([1,2],[[6],[6]]); /* [[6],[1,2],[6]] */
lists.intersperse('b','ac'); /* 'abc' */
lists.intersperse({b:2},[{a:1},{b:3}]); /* [{a:1},{b:2},{c:3}] */

intercalate : [x] -> [[x]] -> [x]

Description: Array of Variables returned by flattening the result of interspersing an Array of Variables into an Array of an Array of Variables.

Signature Definition: Give arg 1 an Array of Variables. Give arg 2 an Array of an Array of Variables. Get an Array of Variables.

Example Usage:

lists.intercalate([1],[[5],[5],[5]]); /* = lists.flatten(lists.intersperse([1],[[5],[5],[5]])) // [5,1,5,1,5] */
lists.intercalate(["abc"],[["efg"],["qrs"]]); /* ["efg", "abc", "qrs"] */
lists.intercalate([{a:1}],[[{b:1}],[{c:2}]]); /* [{b:1},{a:1},{c:2}] */

transpose : [[x]] -> [[x]]

Description: Array of an Array of Variables returned by transposing rows and columns of given arguments.

Signature Definition: Give arg 1 an Array of an Array of Variables. Get an Array of an Array of Variables.

Example Usage:

lists.transpose([[1,2,4],[3,4,4]]); /* [[1,3],[2,4],[4,4]] */
lists.transpose([["a","b","c"],["a","b","c"]]); /* [["a","a"],["b","b"],["c","c"]] */

subsequences : [x]|str -> [[x]]

Description: Array of an Array of Variables of all subsequences of a given arguement.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of an Array of Variables.

Example Usage:

lists.subsequences('ab'); /* [[],['a'],['b'],['ab']] */
lists.subsequences([1,2,3]); /* [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] */

permutations : [x]|str -> [[x]]|[str]

Description: Array of an Array of Variables or Array of Strings returned by getting all permutations of a given arguement.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of an Array of Variables or an Array of Strings respectively.

Example Usage:

lists.permutations('abc'); /* ["abc","acb","bac","bca","cab","cba"] */
lists.permutations([1,2,3]); /* [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] */

foldl : x -> [x]|str -> f -> x

Description: Variable returned reducing left to right by applying a binary operator Function (f) on a starting Variable (x), known as the accumulator, and an Array of Variables or a String.

Signature Definition: Give arg 1 a starting Variable (usually a left identity of the binary operator). Give arg 2 an Array of Variables or a String. Give arg 3 a Function (binary operator). Get a Variable.

Example Usage:

reverse = lists.foldl('','abc',function(x,y){ return y.concat(x); }); /* "cba" */
sum = lists.foldl(0,[1,2,3],function(x,y){ return x+y; }); /* 6 */
lists.foldl([], [[1,2],[3,4]], function(x,y) {return x.concat(y) }); /* [1,2,3,4] */

foldl1 : [x]|str -> f -> x

Description: Variant of foldl without a starting Variable (The accumulator begins with the 0th index of the passed Array of Variables or a String). Use with non-empty Arrays or Strings.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function (binary operator). Get a Variable.

Example Usage:

lists.foldl1('abc',function(x,y){ return x.concat(y).toUpperCase() }); /* "ABC" */
lists.foldl1([1,2,3],function(x,y){ return x+y }); /* 6 */

foldr : x -> [x]|str -> f -> x

Description: Variable returned reducing right to left by applying a binary operator Function (f) on a starting Variable (x), known as the accumulator, and an Array of Variables or a String.

Signature Definition: Give arg 1 a starting Variable (usually a right identity of the binary operator). Give arg 2 an Array of Variables or a String. Give arg 3 a Function (binary operator). Get a Variable.

Example Usage:

lists.foldr(0,[1,2,3,4],function(x,y){ return x-y; }); /* -2 */
lists.foldr([],[[1,2],[3,4],[5,6]],function(x,y){ 
  return lists.rev(x).concat(y); 
}); /* [4,3,1,2,5,6] */

foldr1 : [x]|str -> f -> x

Description: Variant of foldr without a starting Variable (The accumulator begins with the 0th index of the passed Array or a String). Use with non-empty Arrays or Strings.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function (binary operator). Get a Variable.

Example Usage:

lists.foldr1([1,2,3],function(x,y){ return x - y }); /* 3 */
lists.foldr1('aabbcc',function(x,y){ return x=='a'? x=y : x.concat(y)}); /* "bbcc" */

flatten || concat : [[x]]|[str] -> [x]|str

Description: Flatten an Array of an Array of Variables or an Array of Strings into an Array of Variables or a String respectively.

Signature Definition: Give arg 1 an Array of an Array of Variables or an Array of Strings. Get an Array of Variables or a String.

Example Usage:

lists.flatten(['abc']); /* 'abc' */
lists.flatten([[1,2],[3,4]]); /* [1,2,3,4] */

concatMap : [x]|str -> f -> [x]|str

Description: Array of Variables or a String returned by mapping a Function over an Array of Variables or a String and flattening the result.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function that produces an Array of Variables or a String. Get an Array of Variables or a String.

Example Usage:

lists.concatMap(['bang','bang'], function(x){ return x+'!'}); /* "bang!bang!" */
lists.concatMap([1,2,3],function(x){ return [[x*2,x/2]] }); /* [[2,0.5],[4,1],[6,1.5]] */
lists.concatMap([{a:1},{b:2}], function(x){
  x.prop = 'hi';  
  return [x]
}); /* [{a:1,prop:"hi"},{b:2,prop:"hi"}]*/

and : [boolean] -> boolean

Description: Boolean returned by the conjunction of an Array of booleans. True if all booleans are true. False if one or more booleans is false.

Signature Definition: Give arg 1 an Array of booleans. Get a boolean.

Example Usage:

lists.and([5>1,5>2,5>3]); /* true */
lists.and([5>1,false,5>3]); /* false */

or : [boolean] -> boolean

Description: Boolean returned by the disjunction of an Array of booleans. True if at least one boolean is true. False if all booleans are false.

Signature Definition: Give arg 1 an Array of booleans. Get a boolean.

Example Usage:

lists.or([5<1,5<2,5>3]); /* true */
lists.or([5<1,5<2,5<3]); /* false */

any : [x]|str -> f -> boolean

Description: Boolean returned by applying a predicate Function to each element in an Array of Variables or a String. True if at least one f(x) is true. False if all f(x) are false.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a predicate Function to be applied to each element of arg 1. Get a boolean.

Example Usage:

lists.any([1,2,3],function(x) { return x < .5}); /* false */
lists.any('abc',function(x) { return x == 'b'}); /* true */

all : [x]|str -> f -> boolean

Description: Boolean returned by applying a predicate Function to each element in an Array of Variables or a String. True if all f(x) are true. False if any f(x) are false.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a predicate Function to be applied to each element of arg 1. Get a boolean.

Example Usage:

lists.all('abc', function(x){ return x==x.toUpperCase() }); /* false */
lists.all([2,4], function(x) { return x > 3 }); /* false */
lists.all([2,4], function(x) { return x%2==0 }); /* true */

sum : [num] -> num

Description: Number returned by summing the numbers of an Array together.

Signature Definition: Give arg 1 an Array of Numbers. Get a Number.

Example Usage:

lists.sum([2,4,6]); /* 12 */
lists.sum([.2,.4,.6]); /* 1.2000000000000002 */

product : [num] -> num

Description: Number returned by computing the product of the numbers of an Array.

Signature Definition: Give arg 1 an Array of Numbers. Get a Number.

Example Usage:

lists.product([2,4,6]); /* 48 */
lists.product([.2,.4,.6]); /* 0.04800000000000001 */

maximum : [num] -> num

Description: Maximum Number returned from numbers of an Array.

Signature Definition: Give arg 1 an Array of Numbers. Get a Number.

Example Usage:

lists.maximum([2,4,6]); /* 6 */
lists.maximum([.2,.4,.6]); /* .6 */

minimum : [num] -> num

Description: Minimum Number returned from numbers of an Array.

Signature Definition: Give arg 1 an Array of Numbers. Get a Number.

Example Usage:

lists.minimum([2,4,6]); /* 2 */
lists.minimum([.2,.4,.6]); /* .2 */

maxList : [[x]] -> [x]

Description: Array of Variables with the maximum length returned from an Array of an Array of Variables.

Signature Definition: Give arg 1 an Array of an Array of Variables. Get an Array of Variables.

Example Usage:

lists.maxList([[1],[2,3]]); /* [2,3] */
lists.maxList([[1,2],[3]]); /* [1,2] */

minList : [[x]] -> [x]

Description: Array of Variables with the minimum length returned from an Array of an Array of Variables.

Signature Definition: Give arg 1 an Array of an Array of Variables. Get an Array of Variables.

Example Usage:

lists.minList([[],[1]]); /* [] */
lists.minList([[1,2],[3]]); /* [3] */

scanl : x -> [x]|str -> f -> [x]

Description: Array of Variables returned building left to right, starting with the accumulator (x) by applying a binary operator Function (f) on a starting Variable (x) and an Array of Variables or a String.

Signature Definition: Give arg 1 a starting Variable. Give arg 2 an Array of Variables or a String. Give arg 3 a Function (binary operator). Get an Array of Variables.

Example Usage:

lists.scanl('.','abc',function(x,y){return x + y}); /* [".",".a",".ab",".abc"] */
lists.scanl(0,[1,2,3],function(x,y){return x + y}); /* [0,1,3,6] */

scanr : x -> [x]|str -> f -> [x]

Description: Array of Variables returned building right to left, starting with the accumulator (x) by applying a binary operator Function (f) on a starting Variable (x) and an Array of Variables or a String.

Signature Definition: Give arg 1 a starting Variable. Give arg 2 an Array of Variables or a String. Give arg 3 a Function (binary operator). Get an Array of Variables.

Example Usage:

lists.scanr('.','abc',function(x,y){return x + y}); /* ["abc.","bc.","c.","."] */
lists.scanr(0,[1,2,3],function(x,y){return x + y}); /* [6,5,3,0] */

mapAccumL : x -> [x]|str -> f -> [x, [x]]

Description: Builds an Array containing a accumulator (x) and the result of applying F to the supplied accumulator and each element of the supplied Array from left to right.

Signature Definition: Give arg 1 a starting Variable (accumulator). Give arg 2 an Array of Variables or a String. Give arg 3 a Function. Get an Array of Variable followed by Array of Variables.

Example Usage:

lists.mapAccumL(5, [2,4,8], function(x,y){ return [x+y,x*y]}); /* [19, [10,28,88]]*/
lists.mapAccumL(5, [2,4,8], function(x,y){ return [y,y]}); /* [8, [2,4,8]] */
lists.mapAccumL(5, [5,5,5], function(x,y){ return [x,x]}); /* [5, [5,5,5]] */

mapAccumR : x -> [x]|str -> f -> [x, [x]]

Description: Builds an Array containing a accumulator (x) and the result of applying f to the supplied accumulator and each element of the supplied Array from right to left.

Signature Definition: Give arg 1 a starting Variable (accumulator). Give arg 2 an Array of Variables or a String. Give arg 3 a Function. Get an Array of Variable followed by Array of Variables.

Example Usage:

lists.mapAccumR(5, [2,4,8], function(x,y){ return [x+y,x*y]}); /* [19, [34,52,40]]*/
lists.mapAccumR(5, [2,4,8], function(x,y){ return [y,y]}); /* [2, [2,4,8]] */
lists.mapAccumR(5, [5,5,5], function(x,y){ return [x,x]}); /* [5, [5,5,5]] */

iterate : x -> num -> f -> [x]

Description: Builds an Array containing the successive application of f to the previous result of f(x) until the stop (num) reaches 0.

Signature Definition: Give arg 1 a Variable. Give arg 2 a Number. Give arg 3 a Function. Get an Array of Variables.

Example Usage:

lists.iterate('a',3,function(ch){return ch+'b'}); /* ["a","ab","abb"] */
lists.iterate([1,2],3,function(xs){return lists.intersperse(6,xs)}); /* [[1,2],[1,6,2],[1,6,6,6,2]] */
lists.iterate(2,4,function(x){ return x*x }); /* [2,4,16,256] */

replicate : x -> num -> [x]

Description: Builds an Array containing replications of x until the stop (num) reaches 0.

Signature Definition: Give arg 1 a Variable. Give arg 2 a Number. Get an Array of Variables.

Example Usage:

lists.replicate(5,5); /* [5,5,5,5,5] */
lists.replicate([1,2],2); /* [[1,2],[1,2]] */
lists.replicate({a:1},2); /* [{a:1},{a:2}] */

cycle : [x]|str -> num -> [x]|str

Description: Builds an Array containing replications of a flattened Array of Variables or a String until the stop (num) reaches 0.

Signature Definition: Give arg 1 an Array of Variables. Give arg 2 a Number. Get an Array of Variables.

Example Usage:

lists.cycle('abc',3); /* "abcabcabc" */
lists.cycle([1,2],2); /* [1,2,1,2] */

unfold : f -> f -> f -> x -> [x]|str

Description: Builds an Array from a seed value. Arg 1 is the predicate Function. If the predicate fails, return an empty Array, otherwise concatenate the result of Arg 2 (f) applied to Arg 4 (x) to the recursive call of unfold calling Arg 3 (f) to Arg 4 (x). This is a corecursive anamorphism.

Signature Definition: Give arg 1 an Function (predicate). Give arg 2 a Function. Give arg 3 a Function. Give arg 4 a Variable (seed).

Example Usage:

function chop8(xs){ 
  return lists.unfold(lists.nil,lists.part(lists.take,8,undefined),lists.part(lists.drop,8,undefined),xs) 
}
chop8([1,2,3,4,5,6,7,8,9]); /* [[1,2,3,4,5,6,7,8],[9]] */
 
function unfoldMap(xs,f) { 
  return lists.unfold(
    lists.nil, 
    lists.part(lists.pipe(f,lists.head),undefined), 
    lists.part(lists.tail,undefined), 
    xs)
}
unfoldMap([1,2],function(x){ return x * 2 }); /* [2,4] */

take : num -> [x]|str -> [x]

Description: Array of Variables returned by taking the first n (num) elements from an Array of Variables or a String.

Signature Definition: Give arg 1 a Number. Give arg 2 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.take(2,[1,2,3]); /* [1,2] */
lists.take(2,'abc'); /* ["a","b"] */

drop : num -> [x]|str -> [x]

Description: Array of Variables returned by dropping the first n (num) elements from an Array of Variables or a String.

Signature Definition: Give arg 1 a Number. Give arg 2 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.drop(2,[1,2,3]); /* [3] */
lists.drop(2,'abc'); /* ["c"] */

splitAt : num -> [x]|str -> [[x],[x]]

Description: Array of two Arrays returned. The first Array contains the first n elements of the supplied Array of Variables or a String. The second contains the rest.

Signature Definition: Give arg 1 a Number. Give arg 2 an Array of Variables or a String. Get an Array of two Arrays of Variables.

Example Usage:

lists.splitAt(2,'abc') /* [['a','b'],['c']] */
lists.splitAt(2,[1,2,3]) /* [[1,2],[3]] */

takeWhile : f -> [x]|str -> [x]

Description: Array of Variables returned by taking elements from an Array of Variables or a String that satisfy a supplied predicate Function until that predicate Function is unsatisfied.

Signature Definition: Give arg 1 a Function. Give arg 2 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.takeWhile([1,2,3,1], function(x){ return x < 3 }); /* [1,2] */
lists.takeWhile([1], function(x){ return x < 2 }); /* [1] */
lists.takeWhile('aabc', function(x){ return x =='a' }); /* ["a","a"] */

dropWhile : f -> [x]|str -> [x]

Description: Array of Variables returned by dropping elements from an Array of Variables or a String that satisfy a supplied predicate Function until that predicate Function is unsatisfied.

Signature Definition: Give arg 1 a Function. Give arg 2 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.dropWhile([1,2,3,4], function(x){ return x < 3 }); /* [3,4] */
lists.dropWhile([1], function(x){ return x < 2 }); /* [] */
lists.dropWhile('aabc', function(x){ return x =='a' }); /* ["b","c"] */

span : [x]|str -> f -> [[x], [x]|str]

Description: An Array of an Array of Variables and Array of Variables or a String (psuedo-tuple) is returned. The first element is the longest prefix of an Array of Variables or a String that satisfy a predicate Function f. The second element is the rest of the list.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of an Array of Variables and Array of Variables or a String (psuedo-tuple).

Example Usage:

lists.span([1,2,3,4], function(x){return x < 3}); /* [[1,2],[3,4]] */
lists.span("abcde", function(x){return x == "a"}); /* [["a"],["b","c","d","e"]] */
lists.span([{a:2},{a:2},{b:2}], function(x){return x.a==2}); /* [[{a:2},{a:2}],[{b:2}]] */

break : [x]|str -> f -> [[x], [x]|str]

Description: An Array of an Array of Variables and Array of Variables or a String (psuedo-tuple) is returned. The first element is the longest prefix of an Array of Variables or a String that do not satisfy a predicate Function f. The second element is the rest of the list.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of an Array of Variables and Array of Variables or a String (psuedo-tuple).

Example Usage:

lists.break([1,2,3,4], function(x){return x < 3}); /* [[],[1,2,3,4]] */
lists.break("abcde", function(x){return x == "a"}); /* [[],"abcde"] */
lists.break([{a:2},{a:2},{b:2}], function(x){return x.a==2}); /* [[],[{a:2},{a:2},{b:2}]] */

stripPrefix : [num]|str -> [num]|str -> [num]|[str]

Description: Argument 1 is the prefix. Argument 2 is the target. The arguments must be of the same type. This function drops the prefix from the target and returns the representation as an Array of Numbers or an Array of Strings.

Signature Definition: Give arg 1 an Array of Numbers or a String. Give arg 2 an Array of Numbers or a String. Get an Array of Numbers or an Array of Strings.

Example Usage:

lists.stripPrefix("abc","abcabce"); /* ["a","b","c","e"] */
lists.stripPrefix([1,2],[1,2,3,4]); /* [3,4] */

group : [num]|str -> [[num]]|[[str]]

Description: An Array of an Array of Numbers or Strings returned where each nested Array contains only equal elements.

Signature Definition: Give arg 1 an Array of Numbers or a String. Get an Array of an Array of Numbers or Strings.

Example Usage:

lists.group([1,1,2,3,3]); /* [[1,1],[2],[3,3]] */
lists.group("mississippi"); /* [["m"],["i"],["s","s"],["i"],["s","s"],["i"],["p","p"],["i"]] */

inits : [x]|str -> [[x]]

Description: An Array of an Array of Variables returned with all the initial segments of the argument, shortest first.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of an Array of Variables.

Example Usage:

lists.inits([1,2,3]); /* [[],[1],[1,2],[1,2,3]] */
lists.inits("abc"); /* [[],["a"],["a","b"],["a","b","c"]] */
lists.inits([{a:2},{b:3}]); /* [[],[{a:2}],[{a:2},{b:3}]] */

tails : [x]|str -> [[x]]

Description: An Array of an Array of Variables returned with all the initial segments of the argument, longest first.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of an Array of Variables.

Example Usage:

lists.tails([1,2,3]); /* [[1,2,3],[1,2],[1],[]] */
lists.tails("abc"); /* [["a","b","c"],["a","b"],["a"],[]] */
lists.tails([{a:2},{b:3}]); /* [[{a:2},{b:3}],[{a:2}],[]] */

isPrefixOf : [num]|str -> [num]|str -> boolean

Description: Test if an Array of Numbers or a String is the prefix of an Array of Numbers or a String. The arguments must be of the same type.

Signature Definition: Give arg 1 an Array of Numbers or a String. Give arg 2 an Array of Numbers or a String. Get a boolean.

Example Usage:

lists.isPrefixOf([1,2],[1,2,3]); /* true */
lists.isPrefixOf("abc","acd"); /* false */
lists.isPrefixOf("ab","abcd"); /* true */

isSuffixOf : [num]|str -> [num]|str -> boolean

Description: Test if an Array of Numbers or a String is the suffix of an Array of Numbers or a String. The arguments must be of the same type.

Signature Definition: Give arg 1 an Array of Numbers or a String. Give arg 2 an Array of Numbers or a String. Get a boolean.

Example Usage:

lists.isSuffixOf([1,2],[1,2,3]); /* false */
lists.isSuffixOf("cd","acd"); /* true */
lists.isSuffixOf("d","abcd"); /* true */

isInfixOf : [num]|str -> [num]|str -> boolean

Description: Test if an Array of Numbers or a String is the infix of an Array of Numbers or a String. The arguments must be of the same type.

Signature Definition: Give arg 1 an Array of Numbers or a String. Give arg 2 an Array of Numbers or a String. Get a boolean.

Example Usage:

lists.isInfixOf([1,2],[1,3,2]); /* false */
lists.isInfixOf("cd","acde"); /* true */
lists.isInfixOf("a","abcd"); /* true */

isSubsequenceOf : [num]|str -> [num]|str -> boolean

Description: Test if an Array of Numbers or a String is the subsequence of an Array of Numbers or a String. The arguments must be of the same type.

Signature Definition: Give arg 1 an Array of Numbers or a String. Give arg 2 an Array of Numbers or a String. Get a boolean.

Example Usage:

lists.isSubsequenceOf([1,2],[1,3,2]); /* true */
lists.isSubsequenceOf("abc","123 abc"); /* true */
lists.isSubsequenceOf("Lol","Laugh out loud"); /* true */

elem : num|str -> [num]|str -> boolean

Description: Test if the Number or a String is in the Array of Numbers or a String.

Signature Definition: Give arg 1 a Number or a String. Give arg 2 an Array of Numbers or a String. Get a boolean.

Example Usage:

lists.elem(2,[1,3,2]); /* true */
lists.elem("2","123 abc"); /* true */

notElem : num|str -> [num]|str -> boolean

Description: Test if the Number or a String is not in the Array of Numbers or a String.

Signature Definition: Give arg 1 a Number or a String. Give arg 2 an Array of Numbers or a String. Get a boolean.

Example Usage:

lists.notElem(0,[1,3,2]); /* true */
lists.notElem("a","abc"); /* false */

lookup : num|str -> [[num|str,x]] -> boolean

Description: Retreive the value of a key in an Array of an Array of Variables where position 0 is the key and position 1 is the value (associative array).

Signature Definition: Give arg 1 a Number or a String. Give arg 2 an Array of an Array containing a Number or a String as the key and a Variable as the value. Get a Variable (value).

Example Usage:

lists.lookup("a",[["a",2],["b",3]]); /* 2 */
lists.lookup("ab",[["ab",2],["b",3]]); /* 2 */
lists.lookup(1,[[1,{a:2}],["b",3]]); /* {a:2} */

find : [x]|str -> f -> x

Description: Retreive a Variable by applying a predicate Function to an Array of Variables or a String. Returns "Nothing" if there is no match.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get a Variable.

Example Usage:

lists.find([{a:2}], function(x) { return x.a == 2 }); /* {a:2} */
lists.find([[1,2]], function(x) { return x[0] == 1}); /* [1,2] */
lists.find([1,2,3], function(x) { return x == 0 }); /* "Nothing" */

filter : [x]|str -> f -> [x]

Description: An Array of Variables returned by applying a predicate Function to an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of Variables.

Example Usage:

lists.filter([{a:1},{b:2}], function(obj) { return Object.keys(obj).length > 0 }); /* [{a:1},{b:2}] */
lists.filter("abc", function(char) { return char == "a" }); /* ["a"] */
lists.filter([[1],[1,2]], function(arr) { return arr.length > 1 }); /* [[1,2]] */

partition : [x]|str -> f -> [[x],[x]]

Description: An Array of two Arrays of Variables returned by applying a predicate Function to an Array of Variables. The Array of Variables at position 0 are the Variables that satisfy the predicate Function. The Array of Variables at position 1 are the Variables that do not satisfy the predicate Function.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of two Arrays of Variables.

Example Usage:

lists.partition("Abc", function(char) { return char.startsWith("b") }); /* [["b"],["A","c"]] */
lists.partition([1,2,3,4], function(num) { return num % 2 == 0 }); /* [[2,4],[1,3]] */
lists.partition([{a:1},{b:2,a:2}], function(obj) { return obj.a == 2 }); /* [[{b:2,a:2}],[{a:1}]] */

bang : num -> [x] -> x

Description: Variable returned by fetching the Variable at the given index (Number).

Signature Definition: Give arg 1 a Number. Give arg 2 an Array of Variables. Get a Variable.

Example Usage:

lists.bang(1,[0,{a:2},1]); /* {a:2} */
lists.bang(0,[[1,2],4]); /* [1,2] */
lists.bang(3,[1,2]); /* -1 */

elemIndex || indexOf : num|str -> [num]|str -> num

Description: Returns the index Number of the first occurance of a Number or a String from an Array of Numbers or a String.

Signature Definition: Give arg 1 a Number or a String. Give arg 2 an Array of Numbers or a String. Get a Number.

Example Usage:

lists.elemIndex(1,[1,2,1]); /* 0 */
lists.elemIndex("b","abc"); /* 1 */
lists.elemIndex(2,[0,1]); /* -1 */

elemIndices : num|str -> [num]|str -> [num]

Description: Returns an Array of Numbers representing the indices of the Number or a String from an Array of Numbers or a String.

Signature Definition: Give arg 1 a Number or a String. Give arg 2 an Array of Numbers or a String. Get an Array of Numbers.

Example Usage:

lists.elemIndices(1,[1,2,1]); /* [0,2] */
lists.elemIndices("a","aba"); /* [0,2] */
lists.elemIndices(2,[0,1]); /* [] */

findIndex : [x]|str -> f -> num

Description: Returns the index Number of the first occurance of the result of applying a predicate Function to an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get a Number.

Example Usage:

lists.findIndex([1,2,3], function(num){ return num % 2 == 0 }); /* 1 */
lists.findIndex([{a:2}], function(obj){ return obj.a == 2 }); /* 0 */
lists.findIndex("ab%c", function(char){ return char == "%" }); /* 2 */

findIndices : [x]|str -> f -> [num]

Description: Returns an Array of Numbers representing the indices of the result of applying a predicate Function to an Array of Variables or a String.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of Numbers.

Example Usage:

lists.findIndices([1,2,3,4], function(num) { return num % 2 == 0 }); /* [1,3] */
lists.findIndices([{a:2},{b:3},{a:2}], function(obj) { return obj.a == 2 }); /* [0,2] */
lists.findIndices("AbAbA", function(char) { return char == "A" }); /* [0,2,4] */

zip || unzip : [[a,b,..,n],[c,d,..,n],..,n] -> [[a,c,..,n],[b,d,..,n],..,n]

Description: Takes an Array of an Array of Variables and returns an Array of an Array of Variables with corresponding Variables.

Signature Definition: Give arg 1 an Array of an Array of Variables. Get an Array of Variables.

Example Usage:

lists.zip([[1,2],[3,4],[5,6]]); /* [[1,3,5],[2,4,6]] */
lists.zip(lists.zip([[1,2],[3,4],[5,6]])); /* unzip example [[1,2],[3,4],[5,6]] */
lists.zip([[1,'l'],[3,'o'],[5,'l']]); /* [[1,3,5],["l","o","l"]] */

zipWith : [[a,b,..,n],[c,d,..,n],..,n] -> f -> [x]

Description: Takes an Array of an Array of Variables and a Function and returns an Array of Variables with the results being the Function applied to the corresponding zipped Array of Variables.

Signature Definition: Give arg 1 an Array of an Array of Variables. Give arg 2 a Function. Get an Array of Variables.

Example Usage:

lists.zipWith([[1,3],[1,2]],lists.sum); /* [2,5] */
 
function addThenMultiply(arr) {
  var res = 0; 
  lists.each(arr, function(num, i) {  
    i != 2 ? res += num : res *= num
  });
  return res;
}
lists.zipWith([[1,3],[1,2],[4,5]],addThenMultiply); /* [8, 25] */

lines : str -> [str]

Description: Returns an Array of Strings as the result of breaking a String at each new line character (\u000A). The resultant Array does not contain any new line characters.

Signature Definition: Give arg 1 a String. Get an Array of Strings.

Example Usage:

lists.lines("l\no\nl"); /* ["l","o","l"] */
lists.lines("Hey\nthere"); /* ["Hey","there"] */

words : str -> [str]

Description: Returns an Array of Strings as the result of breaking a String at each space character (\u0020). The resultant Array does not contain any space characters.

Signature Definition: Give arg 1 a String. Get an Array of Strings.

Example Usage:

lists.words("break it up"); /* ["break","it","up"] */

unlines : [str] -> str

Description: Returns a String with a new line character appended to each String of the Array that it joins.

Signature Definition: Give arg 1 an Array of Strings. Get a String.

Example Usage:

lists.unlines(["break","it","up"]); /* "break\nit\nup\n" */

unwords : [str] -> str

Description: Returns a String with a space character appended to each String of the Array that it joins.

Signature Definition: Give arg 1 an Array of Strings. Get a String.

Example Usage:

lists.unwords(["break","it","up"]); /* "break it up " */

nub || uniq || unique : [num|str]|str -> [num|str]

Description: Remove duplicates from a String or an Array of Numbers and/or Strings. Keep the first occurence of each element.

Signature Definition: Give arg 1 a String or an Array of Numbers and/or Strings. Get an Array of Numbers and/or Strings.

Example Usage:

lists.nub("abbc"); /* ["a","b","c"] */
lists.nub([1,2,"a","b","a",1]); /* [1,2,"a","b"] */
lists.nub([1,2,2,3]); /* [1,2,3] */ 

delete : x -> [x]|str -> [x]

Description: Return an Array of Variables from the result of removing the first occurence of a Variable from an Array of Variables or a String. Does not work with Objects.

Signature Definition: Give arg 1 a Variable. Give arg 2 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.delete('a','bab'); /* ["b","b"] */
lists.delete([1],[[1,2],[1]]); /* [[1,2]] */
lists.delete(1,[2,1,2,1]); /* [2,2,1] */ 

difference || diff : [num|str]|str -> [num|str]|str -> [x]

Description: Return an Array of Variables whose elements are the difference between Argument 1 and Argument 2.

Signature Definition: Give arg 1 a String or an Array of Numbers and/or Strings. Give arg 2 a String or an Array of Numbers and/or Strings. Get an Array of Variables.

Example Usage:

lists.difference(['acd',1],['acd']); /* [1] */
lists.difference('acd','ab'); /* ["c","d"] */
lists.difference([1,2],[1,2]); /* [] */ 

union : [num|str]|str -> [num|str]|str -> [x]|str

Description: Return an Array of Variables whose elements are the union between Argument 1 and Argument 2.

Signature Definition: Give arg 1 a String or an Array of Numbers and/or Strings. Give arg 2 a String or an Array of Numbers and/or Strings. Get an Array of Variables or a String.

Example Usage:

lists.union("a","b"); /* "ab" */
lists.union([1,4,'a'],[1,3,'b']); /* [1,4,"a",3,"b"] */

intersect : [num|str]|str -> [num|str]|str -> [x]

Description: Return an Array of Variables whose elements are the intersection between Argument 1 and Argument 2.

Signature Definition: Give arg 1 a String or an Array of Numbers and/or Strings. Give arg 2 a String or an Array of Numbers and/or Strings. Get an Array of Variables.

Example Usage:

lists.intersect('a','ba'); /* ["a"] */
lists.intersect([1,4,'a'],[1,3,'b']); /* [1] */

sort : [x]|str -> [x]

Description: Return an Array of Variables that are sorted by the Ordering Function lists.compare.

Signature Definition: Give arg 1 an Array of Variables or a String. Get an Array of Variables.

Example Usage:

lists.sort('acb'); /* ["a","b","c"] */
lists.sort([[3,4],[1,2]]); /* [[1,2],[3,4]] */
lists.sort([2,1,-1,1]); /* [-1,1,1,2] */

insert : x -> [x] -> [x]

Description: Inserts an element into the first position of the Array of Variables where the element is less than or equal (defined by lists.compare) to the Variable from the Array it is being compared to.

Signature Definition: Give arg 1 a Variable. Give arg 2 an Array of Variables. Get an Array of Variables.

Example Usage:

lists.insert(1,[2,1,2]); /* [1,2,1,2] */
lists.insert(4,[1,3,5,7,9]); /* [1,3,4,5,7,9] */

nubBy : [x]|str -> f -> [x]

Description: Remove duplicates from an Array of Variables or a String based on a user supplied Function defintion of equality. Keep the first occurence of each element.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of Variables.

Example Usage:

lists.nubBy([8,7,5,3,2], function(x,y) { return x + y == 10 }); /* [8,7,5] */
lists.nubBy(["query=string, another=string","query=string, hey=man"], function(x,y) { 
  return x.split(',')[0] == y.split(',')[0]; // define equality on query=string 
}); /* ["query=string, another=string"] */
lists.nubBy([{a:1},{a:1, b:2},{b:2}], function(obj1, obj2) { 
  return obj1.b == obj2.b; // define equality on the b property
}); /* [{a:1},{a:1, b:2}] */

deleteBy : x -> [x]|str -> f -> [x]

Description: Return an Array of Variables from the result of removing the first occurence of a Variable or a String that matches a user supplied Function definition of equality from an Array of Variables.

Signature Definition: Give arg 1 a Variable. Give arg 2 an Array of Variables. Give arg 3 a Fucntion. Get an Array of Variables.

Example Usage:

lists.deleteBy(4, [6,8,10,12], function(arg1,y) { return y % arg1 == 0 }); /* [6,10,12] */
lists.deleteBy(2, [{a:2},{b:2,e:2},{c:2}], function(arg1, obj) { return lists.keys(obj).length == arg1 }); /* [{a:2},{c:2}] */

deleteFirstsBy : [x]|str -> [x]|str -> f -> [x]

Description: Return the first Array of Variables or String passed with the first occurence of each element from the second Array of Variables or String removed based on a user supplied Function definition of equality.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 an Array of Variables or a String. Give arg 3 a Fucntion. Get an Array of Variables.

Example Usage:

lists.deleteFirstsBy([1,2,3,4,3],[3], function(x,y) { return x==y }); /* [1,2,4,3] */
lists.deleteFirstsBy("baba","a", function(x,y) { return x==y }); /* ["b","b","a"] */

unionBy : [x] -> [x] -> f -> [x]

Description: Return an Array of Variables as the union between Argument 1, Argument 2, and the user supplied Function definition of equality.

Signature Definition: Give arg 1 an Array of Variables. Give arg 2 an Array of Variables. Give arg 3 a Fucntion. Get an Array of Variables.

Example Usage:

lists.unionBy([1,2,3,4],[4,6,9,10], function(x,y) { return x * 3 == y }); /* [1,2,3,4,4,10] */
lists.unionBy(["a","b","c"], ["d","e","f"], function(x,y) { 
    var same = y == 'd' ? 'a' : y; 
    return x == same; // "d" is the same as "a"
}); /* ["a","b","c","e","f"] */

intersectBy : [x]|str -> [x]|str -> f -> [x]

Description: Return an Array of Variables as the intersection between Argument 1, Argument 2, and the user supplied Function definition of equality.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 an Array of Variables or a String. Give arg 3 a Fucntion. Get an Array of Variables.

Example Usage:

lists.intersectBy([1,2,3,4],[4,8,12,16,20], function(x,y) { return x * x == y }); /* [2,4] */

groupBy : [x]|str -> f -> [[x]]

Description: Return an Array of Variables where each nested Array is a group of equal elements. Equality is defined by the user supplied Function.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Fucntion. Get an Array of an Array of Variables.

Example Usage:

lists.groupBy([1,2,3,4,5,6,7,8,9], function(x,y){ return ((x*y) % 3) == 0}); /* [[1],[2,3],[4],[5,6],[7],[8,9]] */
lists.groupBy([1,2,3,4,5,6,7,8,9], function(x,y){ return x + 1 == y}); /* [[1,2],[3,4],[5,6],[7,8],[9]] */

sortBy : [x]|str -> f -> [x]

Description: Return an Array of Variables that are sorted based on the user supplied Ordering Function.

Signature Definition: Give arg 1 an Array of Variables or a String. Give arg 2 a Function. Get an Array of Variables.

Example Usage:

function oddsFirst(x,y) { 
    return x % 2 == 1 ? 'LT' : 'GT'
}
lists.sortBy([1,2,3,4,5,6,7], oddsFirst); /* [1,3,5,7,6,4,2] */

insertBy : x -> [x]|str -> f -> [x]

Description: Inserts an element into the first position of the Array of Variables based on the user supplied Ordering Function.

Signature Definition: Give arg 1 a Variable. Give arg 2 an Array of Variables or a String. Give arg 3 a Function. Get an Array of Variables.

Example Usage:

function fn(x,y) { 
    return (x+y) < (x*y) ? 'LT' : 'GT'
}
lists.insertBy(4, [0,1,3,5,7,9], fn); /* [0,1,4,3,5,7,9] */

maximumBy : [x]|str -> f -> x

Description: The largest element of a non-empty Array of Variables or a String where the definition of "largest" comes from the user supplied Ordering function.

Signature Definition: Give arg 1 a Variable. Give arg 2 an Array of Variables or a String. Give arg 3 a Function. Get an Array of Variables.

Example Usage:

lists.maximumBy([[1,3],[2]], lists.compare); /* [2] */
function compareLength(x,y) { 
    return  x.length > y.length ? 'GT' : 'LT'
}
lists.maximumBy([[1,3],[2]], compareLength); /* [1,3] */

minimumBy : [x]|str -> f -> x

Description: The least element of a non-empty Array of Variables or a String where the definition of "least" comes from the user supplied Ordering function.

Signature Definition: Give arg 1 a Variable. Give arg 2 an Array of Variables or a String. Give arg 3 a Function. Get an Array of Variables.

Example Usage:

lists.minimumBy([[1,3],[2]], lists.compare); /* [1,3] */
function compareLength(x,y) { 
    return  x.length > y.length ? 'GT' : 'LT'
}
lists.minimumBy([[1,3],[2],[]], compareLength); /* [] */

genericExcludeChar : str -> str -> [str]

Description: Strips an arbitrary character (String) from a String. This function is the primary work horse of lists.lines and lists.words.

Signature Definition: Give arg 1 a String. Give arg 2 a String. Get a an Array of Strings.

Example Usage:

lists.genericExcludeChar("a","abc"); /* ["bc"] */
 
function myLines(str) { return lists.genericExcludeChar('\u000A', str); };
myLines("abc\nd"); /* ["abc","d"] */

forEach || each : x -> f -> x

Description: An enhanced polyfill of Array.prototype.forEach. Works for properties of Objects. This function is meant to alter mutable state.

each's arguments are:

Argument 1: Iterable Variable. Argument 2: Function. Argument 3: (optional) Caller (or context).

When called, each applies the Function to each iterable Variable with its optional caller.

The Function's arguments are:

Argument 1: The Variable of the iteration at the specific index. Argument 2: The index at that specific iteration. Argumnet 3: The original iterable Variable.

The original (unchanged) iterable Variable is returned.

Signature Definition: Give arg 1 a Variable. Give arg 2 a Function. (optionally) Give arg 3 a Caller (this, self, etc.). Get a Variable.

Example Usage:

var arr = [];
lists.forEach([1,2,3], function(num, index, array123) {
    arr.push(num * 2);
}); /* [1,2,3] */
 
console.log(arr); /* [2,4,6] */

keys : obj -> [str]

Description: A polyfill of Object.keys. Returns an Array of Strings representing the iterable properties of the Object not from its inherited chained properties.

Signature Definition: Give arg 1 an Object. Get an Array of Strings.

Example Usage:

lists.keys({a:2, b:1}); /* ["a","b"] */

enumeration || enum : num -> num -> [num]

Description: Create an enumeration in the form of an Array of Numbers where Argument 1 is the start Number and Argument 2 is the stop Number.

Signature Definition: Give arg 1 a Number. Give arg 2 a Number. Get an Array of Numbers.

Example Usage:

lists.enum(0,5); /* [0,1,2,3,4,5] */

composeL || pipe : f[,..,f] -> f

Description: Return a Function that represents the composition of Functions passed as Arguments. These Functions will be applied from rightmost to leftmost to the returned Function's Argument.

Signature Definition: Give arg 1 N number of Functions. Get a Function.

Example Usage:

var sumThenSqrt = lists.pipe(Math.sqrt, lists.sum);
sumThenSqrt([4,4,4,4]); /* 4 */

composeR || sequence : f[,..,f] -> f

Description: Return a Function that represents the composition of Functions passed as Arguments. These Functions will be applied from leftmost to rightmost to the returned Function's Argument.

Signature Definition: Give arg 1 N number of Functions. Get a Function.

Example Usage:

var sumThenSqrt = lists.sequence(lists.sum, Math.sqrt);
sumThenSqrt([4,4,4,4]); /* 4 */

partial || part : f -> x[,..,x] -> f

Description: Return a partially applied Function where any number of a Function's arguments may be left undefined using undefined as a filler variable to be filled when the Function is called.

Signature Definition: Give arg 1 a Function. Give arg 2,..,n a filled or unfilled Variable. Get a Function.

Example Usage:

var myAny = lists.part(lists.any, undefined, function(x) { return x == 1 });
myAny([1,2]); /* true */
myAny([2]); /* false */

flip : f -> f

Description: Return an equivalent Function whose arguments are 'flipped' or reversed.

Signature Definition: Give arg 1 a Function. Get a Function.

Example Usage:

var flippedAny = lists.flip(lists.any);
flippedAny(function(x){return x == 1}, [1,2]); /* true */

compare : x -> x -> str

Description: The only Ordering Function provided in Lists. Returns a String that is the representation of comparing both Arguments with the native JavaScript comparator operators. Ordering Functions are used to redefine how Variables are ordered.

Signature Definition: Give arg 1 a Variable. Give arg 2 a Variable. Get a String.

Example Usage:

lists.compare(1,2); /* "LT" */
lists.compare(2,1); /* "GT" */
lists.compare("b","b"); /* "EQ" */

bubbleSort : [num] -> [num]

Description: A generic bubblesort algorithm for sorting an Array of Numbers.

Signature Definition: Give arg 1 an Array of Numbers. Get an Array of Numbers.

Example Usage:

lists.bubbleSort([3,2,5,1]); /* [1,2,3,5] */

mergeSort : [num] -> [num]

Description: A generic mergesort algorithm for sorting an Array of Numbers.

Signature Definition: Give arg 1 an Array of Numbers. Get an Array of Numbers.

Example Usage:

lists.mergeSort([3,2,5,1]); /* [1,2,3,5] */

Readme

Keywords

Package Sidebar

Install

npm i lists

Repository

github.com/kurtlocker/lists

Homepage

github.com/kurtlocker/lists

Weekly Downloads

13

Version

0.2.15

License

MIT

Last publish

Collaborators

  • heavymedl
Try on RunKit
Report malware