API

I add all always and any apply arity arityof at both call clone comp compose concat cond contains converge curry div drop each either eq eql evolve filter firstfn flip fold1 fold foldr1 foldr get gt gte has head iif index indexfn isdef isplain join keys keyval last lastfn lcase len lt lte map match max maybe merge min mixin mod mul not nth ofilter omap once or pall partial partialr pfail pick pipe plift replace reverse search set shallow slice sort split sub tail take tap trim type typeis ucase unapply uniq uniqfn values zip zipobj zipwith

Type functions

Functions operating on types.

I

The identity function (x) -> x.

:: (a) -> a

isdef

Checks whether argument is defined, i.e. not null and not undefined.

isdef(a) :: a -> Boolean

args	desc
`a`	Anything to check for `null`/`undefined`.

isdef example

isdef null          # false
isdef undefined     # false
isdef ''            # true
isdef 0             # true

isplain

Checks whether an object o is plain (created using {} or new Object).

isplain(o) :: {*} -> Boolean

args	desc
`o`	Anything to test for plain.

isplain example

isplain null          # false
isplain new Date      # false
isplain {}            # true
isplain a:42          # true

type

Tells what type an object is. Returns one of 'array', 'boolean', 'date', 'null', 'number', 'object', 'string' or 'undefined'.

type(a) :: a -> String

args	desc
`a`	Object to find type for.

type example

type 'abc'     # 'string'
type 42        # 'number'
type null      # 'null'
type {}        # 'object'
type undefined # 'undefined'

typeis

Checks that the first argument is of the type specified in the second.

typeis(a,s) :: String, a -> Boolean
typeis(s)(a) :: String -> a -> Boolean

args	desc
`a`	Object to check type of.
`s`	Type to check for. One of the returned types in `type`.

typeis example

typeis 'abc', 'string'     # true
typeis null, 'string'      # false
typeis a, type(a)          # true
typeis 42, 'number'        # true
isnum = typeis('number')
isnum 42                   # true

Function functions

Functions operating on functions.

always

Creates a function that always returns the initial parameter.

always(a) :: a -> * -> a

The resulting function is plifted.

args	desc
`a`	value to always return

always example

fn = always 42
fn()               # 42
fn(12345)          # 42

apply

Applies the function with the given arguments array. This is equivalent to fn.apply(this,args) and is here due to being curried. The inverse of apply

apply(fn)(as) :: (a, ..., z -> r1) -> [a] -> r1

args	desc
`fn`	Function to apply
`as`	Arguments array

apply example

fn = apply Math.max
fn [2,4,3]           # 4

arity

Forces function arity.

To make a function f1 of f that reports a certain arity we use the form f1 = arity(f,n) where n is the number of arguments we want f to report (f1.length will equal n). Note that this doesn't stop f1 from receiving more arguments.

arity(f,n) :: (a... -> a), n -> (a... -> a)
arity(n)(f) :: n -> (a... -> a) -> (a... -> a)

args	desc
`f`	Function to make a new function with fixed arity of.
`n`	The arity of the new function.

unary

Same as arity(1).

binary

Same as arity(2).

ternary

Same as arity(3).

arity example

myconcat = (as....) -> [].concat as...
arityof myconcat   # 0 for variadic functions.

myconcat2 = arity(2) myconcat   # could have used 'binary myconcat'
arityof myconcat2 # 2
myconcat2 1, 2    # [1,2]
myconcat2 1, 2, 3 # [1,2,3] SURPRISE! (or not)

arityof

Checks the arity of a function arityof(f) returns the number of arguments f takes (same as f.length).

arityof(f) :: (a... -> a) -> Number

args	desc
`f`	Function to check arity of.

arityof example

arityof (->)        # 0
arityof I           # 1
arityof ((a,b)->)   # 2
arityof type        # 1
arityof typeis      # 2
arityof arity       # 2

call

Calls the first argument with the consequent.

call(fn, a,b,c) :: (* -> a), * -> a

args	desc
`fn`	Function to call
`a`	variadic number of arguments to call function with.

call example

call add, 1, 2        # 3

compose

Makes a composition function out of a variable number of functions compose(f3,f2,f1) becomes f3(f2(f1))) with the rightmost function being invoked first (the opposite is pipe).

The result is curried if the rightmost function is of arity > 1.

h = compose(f,g)
z = h(1,2)
z = h(2)(1)

is equivalent to:

y = g(1,2)
z = f(y)

compose(as...) :: ((y -> z), (x -> y), ..., (b -> c), (a... -> b)) -> (a... -> z)

All arguments are plifted.

args	desc
`as...`	Variable number of functions to compose.

compose example

div10 = div(10)
add50 = add(50)
pow   = (a,b) -> Math.pow(a,b)
calc  = compose div10, add50, pow
calc(10,2)  # 15 or (10 ^ 2 + 50) / 10
calc(2)(10) # 15

cond

Conditional function invokation. Sort of like a switch-case.

[ [condition1, when1],
  [condition2, when2],
  ...
]

The produced function will attempt condition 1, 2, etc until one is truthy in which case the corresponding when is invoked with the same arguments.

cond(cs) :: [[(* -> Boolean), (* -> a)],[(* -> Boolean), (* -> a)],...] -> a

args	desc
`cs`	Array of arrays with conditions/when.

cond example

fn = cond [
  [lt(10), always("less than 10")]
  [lt(50), always("less than 50")]
  [always(true), always("something else")]
]

fn 5     # "less than 10"
fn 49    # "less than 49"
fn 110   # "something else"

curry

Takes a function f with multiple arguments and turns that into f1 that can be partially applied by providing less arguments than the original (see currying).

Curry argument order is reversed (sort of the whole point of fnuc), i.e. (a,b,c) becomes (c)(b)(a) however the curried function can still be invoked with multiple arguments in the original order.

Multiple arguments are provided left-to-right.
Partial arguments are filled in right-to-left.

Note that currying only makes sense for functions of arity > 1. This means variadic functions can't be curried without "forcing" an arity.

curry(f) :: (a... -> a) -> (a... -> a)

args	desc
`f`	Function to make a curried version of.

curry example

f  = curry (a, b, c) -> a + b/c
f(5, 20, 10)   # 7
f(10)(20)(5)   # 7 YAY!

Multiple arguments that are still less than the total arity of `f` are
provided in the original order but filled in right-to-left.

f(10)(5, 20)   # 7 i.e. (c)(a, b)
f(20, 10)(5)   # 7 i.e. (b, c)(a)

A variadic function must have a forced arity to be curryable.

f = curry ternary concat
f(1,2,3,4)       # [1,2,3,4] SURPRISE! (or not)
f(3)(2)(1)       # [1,2,3]
f(4)(3)(2)(1)    # TypeError: object is not a function

converge

converge(fn1, fn2, ..., fnn, after)(a1, a2, ..., an)

Creates a function that passes its arguments (a1-an) to fn1-fnn whose result are in arguments to the first function (after).

:: (((a1, ... an) -> x1), ... ((a1, ... an) -> xn), (x1, ..., xn) -> r)) -> (a1, ... an) -> r

All arguments are plifted.

args	desc
`fn1`	Function for first argument to after.
`fn2`	Function for second argument to after.
`after`	Function that willl be invoked with results of fn1-fnn.
Variadic
`ret`	A function accepting arguments to fn1-fnn

converge example

mul2 = (c) -> c * 2
mul3 = (c) -> c * 3
add  = (a, b) -> a + b
fn = converge mul2, mul3, add
fn(4)                          # add (4*2), (4*3) == 20

flip

Makes a function that reverses the argument order of the given function. Flipping is commutative so that flipping a flipped function returns the orginal, i.e. f == flip(flip(f)).

Flipping works for curried functions and reverses the order of the curry.

Flipping also works for partially applied curried functions.

flip(f) :: (a, b, ..., x, y -> z) -> (y, x, ..., b, a -> z)
flip(f) :: (y -> x -> ... -> b -> a -> z) -> (a -> b -> ... -> x -> y -> z)

args	desc
`f`	Function to reverse arguments of.

flip example

f = flip curry ternary concat
f(1, 2, 3)    # [3,2,1]
f(3)(2)(1)    # [3,2,1] the curry was flipped
f3 = f(3)
g3 = flip f3  # flipping partially applied
f3(2)(1)      # [3,2,1]
g3(2)(1)      # [3,1,2]

iif

Inline if accepts three functions, a test function, one for true and one for false.

The returned function will pass any arguments to the test function and then either to true/false depending on the test.

iif(c,t,f) :: (a -> bool), (a -> b), (a -> c) -> a -> b|c

The resulting function is plifted.

args	desc
`c`	Condition function that evaluates to truthy/falsey.
`t`	Function to invoke if `fc` is truthy.
`f`	Function to invoke if `fc` is falsey.

iif example

iseven = (a) -> a % 2 == 0
evens  = (a) -> a / 2
odds   = (a) -> a * 2
fn = iif iseven, evens, odds
fn(3)                          # 6  (3 is odd, 3*2)
fn(4)                          # 2  (4 is even, 4/2)

maybe

Wraps a function and maybe invokes it, if the applied parameter(s) are non-null/non-undefined.

Can be thought of as a "guard" against null/undefined.

maybe(fn) :: (a -> b) -> a|null -> b|null

The resulting function is plifted.

args	desc
`fn`	Function to wrap.

maybe example

just42 = -> 42
fn = maybe just42
fn 0                 # 42
fn 1                 # 42
fn null              # undefined, and just42 was not invoked

nth

Produces a function that returns the nth argument to that function (counting from 0).

nth(n) :: (n) -> (a1, a2, ... az) -> an

args	desc
`n`	the argument number

nth example

fn = nth(1)
fn('a', 'b')         # 'b'
fn(5,4,3,2,1)        # 4

once

Wraps a function and guarantees it is invoked only once. The result is cached and subsequent invokations the result is returned without invoking the original function.

once(fn) :: (a -> b) -> (a -> b)

args	desc
`fn`	the function to wrap

once example

fn = once add(10)
fn(2)             # 12
fn(4)             # 12

pall

Given an array of promises, produces a promise that will resolve with the values when all promises in the array resolves. If no promises in array the function synchronously returns an array with the same content.

pall(as) :: [a | Promise a] -> [a] | Promise [a]

args	desc
`as`	Array of values/promises.

pall example

# helper function that resolves a promise to a value after 1 second.
later = (a) -> (new Promise (rs) -> setTimeout rs, 1000).then -> a

pall [1,2,3]                          # [1,2,3] - synchronously
pall([1,later(2),3]).then console.log # [1,2,3] - after one second

partial

Creates a function that has the original function partially applied from the left (see also partialr).

partial ((a,b) -> a/b), 10 makes a function that will receive one additional argument x to divide 10 by x.

partial(f,as...) :: ((a... -> a), a, b, ...) -> (a... -> a)

args	desc
`f`	Function to apply arguments for.
`as...`	Variable number of arguments to apply from the left.

partial example

l     = [1,2,3,...]
even  = (a) -> a % 2 == 0    # even number filter
fl    = partial filter l    # fl always filters mylist
le    = fl even              # keep only even

partialr

Creates a function that has the original function partially applied from the right (see also partial).

partialr ((a,b) -> a/b), 10 makes a function that will receive one additional argument x to divide x by 10.

partialr(f,as...) :: ((a... -> a), a, b, ...) -> (a... -> a)

args	desc
`f`	Function to apply arguments for.
`as...`	Variable number of arguments to apply from the right.

partialr example

l     = [1,2,3,...]
even  = (a) -> a % 2 == 0         # even number filter
fr    = partial filter even       # applies even filter to any list
le    = fr l                      # keeps only even

pfail

Same as plift only, the function is only invoked if any promise arguments are rejected. Furthermore the plift is shortcut, so the first rejection (if multiple) is the only one invoking the function.

pfail(f) :: ((a, b, ..., z) -> a0) -> (a, b, ..., z) -> a0)

args	desc
`f`	Function to plift and only invoke if any promise arguments fail.

pfail example

fn = pfail (err) -> "failed with #{err}"
fn(42)                  # 42, wrapped function not invoked
fn(Promise.resolve(42)) # 42, wrapped function not invoked
fn(Promise.reject(43))  # "failed with 43"

pipe

Makes a sequence of function out of a variable number of functions pipe(f1,f2,f3) becomes f3(f2(f1))) with the leftmost function invoked first (the opposite is compose).

The result is curried if the leftmost function is of arity > 1.

h = pipe(f,g)
z = h(1,2)
z = h(2)(1)

is equivalent to:

y = f(1,2)
z = g(y)

pipe(as...) :: ((y -> z), (x -> y), ..., (b -> c), (a... -> b)) -> (a... -> z)

All arguments are plifted.

args	desc
`as...`	Variable number of functions to pipe.

pipe example

div10 = div(10)
add50 = add(50)
pow   = (a,b) -> Math.pow(a,b)
calc  = pipe pow, add50, div10
calc(10,2)  # 15 or (10 ^ 2 + 50) / 10
calc(2)(10) # 15

plift

Lifts a function to be promise (.then-able) aware. When any argument to the function is a promise, the function returns a promise for the function evaluation that resolves when the arguments are resolved.

In case all arguments are non-promises, the function evaluates without returning a promise.

plift(f) :: ((a, b, ..., z) -> a0) -> (a, b, ..., z) -> a0)

args	desc
`f`	Function to lift

plift example

# helper function that resolves a promise to a value after 1 second.
later = (a) -> (new Promise (rs) -> setTimeout rs, 1000).then -> a

f = plift (a, b) -> a + b
f(1,2)                       # 3
f(later(1), 2)               # promise that resolves to 3 after 1 second

# to see it in action
f(1, later(2)).then console.log

tap

Runs a value through a function, ignores the result of the function and returns the original value. The mother of all side effects.

tap(4,div(10)) divides 4 by 10 and ignores that result, returns 4.

tap(a,f) :: a, (a -> a) -> a
tap(f)(a) :: (a -> a) -> a -> a

args	desc
`a`	The value to pass as argument to the function.
`f`	The function to pass the argument to (and then ignore).

tap example

log   = (as...) -> console.log as...      # console.log returns undefined
dolog = tap(log)                          # dolog returns same value
calc  = pipe add(3), dolog, div(10)   # log the value between the operations
calc [1,2,3]                              # logs 4...5...6

unapply

Produces a function that takes positional arguments and applies them as an array. The inverse of apply

unapply(f)(a1,a2,...) :: ([a] -> *) -> (a1, a2, ...) -> *

args	desc
`f`	The function to invoke
produced function
`as...`	Arguments to turn into array.

unapply example

unapply(JSON.stringify)(1,2,3)        # '[1,2,3]'

Object functions

Functions operating on objects.

clone

Deep clones a value. The value can be an object, array, date, string, number, boolean, symbol, null or undefined. The only thing that can't be cloned is a non-plain object (other than date).

clone(o) :: * -> *

args	desc
`o`	Value to deep clone.

clone example

clone 42            # 42
clone {a:1}         # {a:1}
clone {a:[1,2,3]}   # {a:[1,2,3]} the nested array is cloned
clone {d:new Date}  # {d:<date>}  the nested date is cloned

evolve

Creates a new object by evolving a shallow copy of object, by applying transformation functions in a second object. Values not transformed are copied by reference.

evolve(o,t) :: {k:v}, {k:(v -> v)} -> {k:v}
evolve(t)(o) :: {k:(v -> v)} -> {k:v} -> {k:v}

args	desc
`o`	Object to evolve.
`t`	Object with transformation functions to apply to `o`.

evolve example

o = {a:1,b:2,c:3}
t = {b:(v) -> v + 40}
o1 = evolve o, t             # {a:1,b:42,c:3}
o1 == o                      # false
badd40 = evolve t            # partial
badd40 o                     # {a:1,b:42,c:3}

eql

Deep equals. a equal to b which will recursively traverse nested arrays and objects. See also eq.

eql(a,b) :: a, a -> Boolean
eql(b)(a) :: a -> a -> Boolean

args	desc
`a`	Argument 1.
`b`	Argument 2.

get

Gets the property value from an object, get o, 'bar' gives the value of o.bar

get(o,k) :: {k,v}, k -> v
get(k)(o) :: k -> {k,v} -> v

args	desc
`o`	Object to get property from.
`k`	The property key.

get example

get {a:1,b:2}, 'b'     # 2
getb = get 'b'         # partial
getb {b:3}             # 3

has

Tells whether an object has a property. has o, 'bar' is the same as o.hasOwnProperty('bar').

has(o,k) :: {k,v}, k -> Boolean
has(k)(o) :: k -> {k,v} -> Boolean

args	desc
`o`	Object to check property on.
`k`	The property key.

has example

has {a:1,b:2}, 'b'     # true
hasb = has 'b'         # partial
hasb {b:3}             # true

keys

Makes an array of the keys of an object. keys o is the same as Object.keys(o).

keys(o) :: {k:v} -> [k]

args	desc
`o`	Object to get keys from.

keys example

keys {a:1,b:2}          # ['a','b']
keys {}                 # []

keyval

Produces a key-value pair as an object.

keyval(k,v) :: (k,v) -> {k:v}

args	desc
`k`	Key value. Preferably a string.
`v`	Value.

keyval example

keyval 'a', 42     # {a:42}

merge

Alters the first object with the key/values from consecutive objects and returns it. Rightmost object takes precedence. Omits values that are undefined.

merge(o, os...) :: {*}, {*}... -> {*}

args	desc
`o`	Target object that will be altered.
`os...`	Variable number of objects to apply left to right.

merge example

merge (t={c:4}), {a:1}, {a:2,b:3}    # t is {a:2,b:3,c:4}
merge {c:4}, {a:1, b:undefined}      # {a:1,c:4}

mixin

Returns a new object with the key/values from consecutive objects set. Rightmost object takes precende. Omits values that are undefined. mixin {a:1}, {b:2} is equivalent to merge {}, {a:1}, {b:2}.

mixin(os...) :: {*}... -> {*}
mixin(o)(o) :: {*} -> {*} -> {*}

args	desc
`os...`	Variable number of objects to apply left to right.

mixin example

mixin (t={c:4}), {a:1}, {a:2,b:3}    # {a:2,b:3,c:4} t is {c:4}
mixin {c:4}, {a:1, b:undefined}      # {a:1,c:4}
fn = mixin {a:1}                     # partial
fn {b:2}                             # {a:1, b:2}

ofilter

Like filter but for objects. The filter function is invoked with key, value (k,v).

ofilter(o,f) :: {k:v}, ((k, v) -> Boolean) -> {k:v}
ofilter(f)(o) :: ((k, v) -> Boolean) -> {k:v} -> {k:v}

args	desc
`o`	The object to invoke filter function on.
`f`	Filter function with signature `(k, v) -> Boolean`. Truthy/falsey return.

ofilter example

f = (k, v) -> k == 'a' or v % 2
o = {a:0, b:1, c:2}
ofilter o, f                # {a:0, b:1}
aOrOdd = ofilter f          # partial
aOrOdd o                    # {a:0, b:1}

omap

Like map but for objects. The mapping function is invoked with key, value (k,v).

omap(o,f) :: {k:v}, ((k, v) -> v) -> {k:v}
omap(f)(o) :: ((k, v) -> v) -> {k:v} -> {k:v}

args	desc
`o`	The object to invoke mapping function on.
`f`	Mapping function with signature `(k, v) -> v`.

omap example

    f = (k, v) -> if k == 'b' then v + 40 else v
    omap {a:1,b:2,c:3}, f                         # {a:1,b:42,c:3}
    bAdd40 = omap(f)                              # partial
    bAdd40 {d:3,b:2}                              # {d:3,b:42}

pick

Picks a number of properties of an object into a new object. The properties to pick can either be supplied as an array of strings or variadic strings.

pick(o,as) :: {k:v}, [k] -> {k:v}
pick(as)(o) :: [k] -> {k:v} -> {k:v}
pick(o,as...) :: {k:v}, k1, k2, k3, ... -> {k:v}
pick(s)(o) :: k -> {k:v} -> {k:v}

args	desc
Array variant
`o`	Object to pick properties from.
`as`	Array of string property names to pick.
Vararg variant
`o`	Object to pick properties from.
`as`	Property names to pick as variable number of string arguments.

pick example

o = {a:1, b:2, c:3}
# as array
pick o,['a','b']            # {a:1, b:2}
p1 = pick ['a',b']          # partial
p1(o)                       # {a:1, b:2}
# as vararg
pick o, 'a', 'b'            # {a:1, b:2}
p3 = pick 'a'               # partial
p3(o)                       # {a:1}

set

Sets a property of an object and returns the same object.

set(o,k,v) :: {k:v}, k, v -> {k:v}
set(v)(k)(o) :: v -> k -> {k:v} -> {k:v}

args	desc
`o`	Object to set a property on.
`k`	Key for the property to set.
`v`	The value to set.

set example

o = {a:1,b:3}
set(o,'a',2)          # {a:2,b:3}
seta3 = set(3)('a')   # partial
setb4 = set(4)('b')   # partial
f = pipe seta3, setb4
f(o)                  # {a:3,b:4}

shallow

Makes a shallow copy of the given argument. The argument can be an object, array, date, string, number, boolean, symbol, null or undefined. However shallowness is only defined for array and object.

shallow(o) :: * -> *

args	desc
`o`	Value to shallow copy.

shallow example

shallow 42            # 42
shallow {a:1}         # {a:1}
shallow {a:[1,2,3]}   # {a:[1,2,3]} the nested array is copy-by-reference
shallow {d:new Date}  # {d:<date>}  the nested date is copy-by-reference

values

Makes an array of the values of an object.

values(o) :: {k:v} -> [v]

args	desc
`o`	Object to get values from.

values example

values {a:1,b:2}, 'b'     # ['1','2']
values {}                 # []

Array functions

Functions operating on arrays.

all

Tests if a condition is fulfilled for all elements of an array. Same as [...].every.

all(as,f) :: [a], (a -> Boolean) -> Boolean
all(f)(as) :: (a -> Boolean) -> [a] -> Boolean

args	desc
`as`	Array to operate on.
`f`	Test function that is truthy/falsy for a single element.

all example

as = [1,0,2]
all as, (a) -> a > 0      # false
all as, (a) -> a >= 0     # true
gt0 = all (a) -> a > 0    # partial
gt0 as                    # false

any

Tests if a condition is fulfilled for any element of an array. Same as [...].some.

any(as,f) :: [a], (a -> Boolean) -> Boolean
any(f)(as) :: (a -> Boolean) -> [a] -> Boolean

args	desc
`as`	Array to operate on.
`f`	Test function that is truthy/falsy for a single element.

any example

as = [1,0,2]
any as, (a) -> a > 0      # true
any as, (a) -> a > 2      # false
gt0 = any (a) -> a > 0    # partial
gt0 as                    # false

at

Returns the element at index n.

Also works for strings.

at(as,n) :: [a], n -> a
at(n)(as) :: n -> [a] -> a

args	desc
`as`	Array to operate on.
`n`	Element index

at example

at(1) ['apple', 'pear', 'banana']    # 'pear'

concat

Concatenates (joins) two or more lists or values. To not be surprising has the same quirks as Array::concat:

Joins multiple arrays to one array.
Joins a mix of array and values to one array.
Joins plain values to one array.

concat(as...) :: [a], a, ... -> [a]

args	desc
`as`	Variable amount of values or arrays to concatenate.

concat example

concat [1,2], [3,4]   # [1,2,3,4]
concat [1,2], 3, 4    # [1,2,3,4]
concat 1, 2, 3, 4     # [1,2,3,4]

contains

Tells if an array contains a value. Same as index(a,v) >= 0.

contains(as,a) :: [a], a -> Boolean
contains(a)(as) :: a -> [a] -> Boolean

args	desc
`as`	Array to check.
`a`	Element to look for.

contains example

contains [1,2,3], 2    # true
contains [1,2,3], 5    # false
cont5 = contains(5)    # partial
cont5 [3,4,5]          # true

drop (array)

See drop

each

Performs side effects for each element of an array without altering the array or returning anything useful. Same as [...].forEach

each(as,f) :: [a], (a -> *) -> undefined
each(f)(as) :: (a -> *) -> [a] -> undefined

args	desc
`as`	Array to loop over.
`f`	Function to invoke for each element.

each example

log = (a) -> console.log a
each [1,2,3], log            # prints 1...2...3
listlogger = each log        # partial
listlogger [1,2,3]           # prints 1...2...3

filter

Creates a new list containing only elements for which a test function is true. Same as [...].filter.

filter(as,f) :: [a], (a -> Boolean) -> [a]
filter(f)(as) :: (a -> Boolean) -> [a] -> [a]

args	desc
`as`	Array to filter.
`f`	Function used to filter array. Truthy to keep element.

filter example

odd = (a) -> a % 2
filter [1,2,3], odd     # [1,3]
fo = filter odd         # partial
fo [1,2,3]              # [1,3]

firstfn

Returns the first element in a list that returns truthy for a test function.

firstfn(as,f) :: [a], (a -> Boolean) -> a
firstfn(f)(as) :: (a -> Boolean) -> [a] -> a

args	desc
`as`	List to work over.
`f`	Test function that is truthy for first element to return.

firstfn [1,2,3,4,5], (a) -> a % 2 == 0      # 2

fold

Performs a fold operation from the left with a seed value. Same as [...].reduce(f, s) but without the additional index or array arguments.

fold(as,f,s) [b], ((a, b) -> a), a -> a
fold(s)(f)(as) a -> ((a, b) -> a) -> [b] -> a

args	desc
`as`	Array to fold.
`f`	Folding function. Signature is `(a,b)`, no index or array.
`s`	Seed value.
folding function
`a`	Value of previous fold operation or `s` for first element.
`b`	Current value from `as`.

fold example

f = (p,c) -> if c % 2 then c + p else p   # sum odd numbers
fold [1,2,3], f, 5                        # 9

fold1

Same as fold but no seed value. Same as [...].reduce(f) but without the additional index and array arguments.

fold1(as,f) [b], ((a, b) -> a) -> a
fold1(f)(as) ((a, b) -> a) -> [b] -> a

args	desc
`as`	Array to fold.
`f`	Folding function. Signature is `(a,b)`, no index or array.
folding function
`a`	Value of previous fold operation or first element for first iteration.
`b`	Current value from `as` or second element for first iteration.

fold1 example

f = (p,c) -> if c % 2 then c + p else p   # sum odd numbers
fold1 [2,3,4], f                          # 5 (in first iteration p=2 and c=3)

foldr

Same as fold but goes right to left with a seed value. Same as [...].reduceRight(f,s) without the additional index or array.

foldr(as,f,s) [b], ((a, b) -> a), a -> a
foldr(s)(f)(as) a -> ((a, b) -> a) -> [b] -> a

args	desc
See fold

foldr1

Same as foldr but no seed value. Same as [...].reduceRight(f) without the additional index or array.

fold1(as,f) [b], ((a, b) -> a) -> a
fold1(f)(as) ((a, b) -> a) -> [b] -> a

args	desc
See fold1

head

Gets the head value of an array.

Also applicable for string.

head(as) :: [a] -> a|undefined

args	desc
`as`	The array to get the head from.

head example

head [1,2,3]   # 1
head []        # undefined

index

Tells the index of a value in an array or -1 if not found. Same as [...].indexOf(a). undefined for empty list.

index(as,a) :: [a], a -> Number
index(a)(as) :: a -> [a] -> Number

args	desc
`as`	The array to look for `a` in.
`a`	Value to look for.

index example

index [1,2,3], 3       # 2
index [1,2,3], 4       # -1

indexfn

Finds the index of first value for which a function is true in an array or -1 if not found. undefined for empty list.

indexfn(as,fn) :: [a], (a -> Boolean) -> Number
indexfn(fn)(as) :: (a -> Boolean) -> [a] -> Number

args	desc
`as`	The array to evaluate `fn` on each element in.
`fn`	Function to run on each element. Truthy will give index.

indexfn example

indexfn [1,2,3], (a) -> a % 2 == 0       # 2
indexfn [1,2,3], (a) -> a > 4            # -1

join

Creates a string from a list by inserting a given string in between each element. Same as [...].join(s)

join(as,s) :: [a], s -> String
join(s)(as) :: s -> [a] -> String

args	desc
`as`	Array to join.
`s`	String to insert in between each element.

join example

join [1,2,3], ''     # '123'
join [1,2,3], '-'    # '1-2-3'

last

Gets the last value of an array. undefined for empty list.

Also applicable for string.

last(as) :: [a] -> a|undefined

args	desc
`as`	The array get the last value of.

last example

last [1,2,3]     # 3
last []          # undefined

lastfn

Returns the last element in a list that returns truthy for a test function.

lastfn(as,f) :: [a], (a -> Boolean) -> a
lastfn(f)(as) :: (a -> Boolean) -> [a] -> a

args	desc
`as`	List to work over.
`f`	Test function that is truthy for last element to return.

lastfn [1,2,3,4,5], (a) -> a % 2 == 0   # 4

map

Creates a new array of transformed values by applying a transformation function to each element. Same as [...].map(f) but does not pass the additional index and array arguments to the transformation function.

map(as,f) :: [a], (a -> b) -> [b]
map(f)(as) :: ((a -> b) -> [a] -> [b]

args	desc
`as`	Array to transform.
`f`	Transformation function. Signature is `(a)` (no index or array).
transformation function
`a`	Current value from `as`.

map example

add1 = (a) -> a + 1
map [1,2,3], add1     # [2,3,4]
ladd1 = map add1      # partial
ladd1 [2,3,4]         # [3,4,5]

reverse

Reverses the array. Same as [...].reverse()

reverse(as) :: [a] -> [a]

args	desc
`as`	Array to reverse.

reverse example

reverse [1,2,3]    # [3,2,1]

slice (array)

See slice

sort

Sorts an array according to a comparator function. Same as [...].sort(f).

The comparator function (a,b) returns:

A number < 0 if a < b
0 if a == b
A number > 0 if a > b

Specifically if (a1,a2) returns something < 0, (a2,a1) must returns something > 0.

sort(as,f) :: [a], (a, a -> Number) -> [a]
sort(f)(as) :: (a, a -> Number) -> [a] -> [a]

args	desc
`as`	Array to sort.
`f`	Comparator function with signature `(a,b)`.
Comparator function
`a`	An element of `as` to compare to `b`.
`b`	An element of `as` to compare to `a`.

sort example

sort [2,1,3]            # [1,2,3]
comp = (a,b) -> b - a
sort [2,1,3], comp      # [3,2,1]
s = sort(comp)          # partial
s [4,1,5,2]             # [5,4,2,1]

tail

The tail of a list, that is, every element apart from the first. The tail of [] is [].

Also applicable for string.

tail(as) :: [a] -> [a]

args	desc
`as`	Array to get tail of.

example

tail [1,2,3]    # [2,3]
tail []         # []

take (array)

See take

uniq

Creates an array where every element occurs only once (given == equality).

Same as uniqfn I.

uniq(as) :: [a] -> [a]

args	desc
`as`	Array to dedupe.

uniq example

uniq [3,1,3,2,1,3,2,1]   # [3,1,2]

uniqfn

Creates an array where every element occurs only once given a function applied for each element.

uniqfn(as) :: [a], (a -> v) -> [a]

args	desc
`as`	Array to dedupe.
`fn`	Function to apply to every value in the array to dedupe.

uniqfn example

uniqfn [6,1,3,4,1,3,2,1], (a) -> a % 3   # [6,1,2]

zip

Takes two (or more) arrays and combines each position into a single array of arrays.

Returned array is the minimum length argument arrays.

zip(as,bs) :: [a], [b] -> [[a,b]]
zip(bs)(as) :: [b] -> [a] -> [[a,b]]
zip(cs...) :: [a], ..., [z] -> [[a,...,z]]

args	desc
`as`	Array/string of values for first value
`bs`	Array/string of values for second value
Variadic
`cs`	Variable number of arrays/strings to use

zip example

zip [1,2,3], ['a','b','c']   # [(1,a),(2,b),(3,c)]

zipobj

Takes two arrays, one with keys and one with values, to make an object with those keys/values.

zipobj(as,bs) :: [a], [b] -> {a0:k0, a1:k2, ..., az:kz}

args	desc
`ks`	Array of keys
`vs`	Array of values. Must be same length as `ks`.

zipobj example

zipobj ['a','b','c'], [1,2,3]   # {a:1, b:2, c:3}

zipwith

Takes two (or more) arrays and combines each position by invoking a function for each position.

zipwith(as,bs,f) :: [a], [b], ((a,b) -> c) -> [c]
zipwith(f)(bs)(as) :: ((a,b) -> c) -> [b] -> [a] -> [c]
zipwith(cs...,f) :: [a], ... [z], ((a,...,z) -> c) -> [c]

args	desc
`as`	Array/string of values for first value to function.
`bs`	Array/string of values for second value to function.
`f`	Function to invoke for each position.
Variadic
`cs`	Variable number of arrays/strings to provide to function.

zipwith example

zipwith(add) [1,2,3], [3,4,5]    # [4,6,8]

String functions

Functions operating on strings.

lcase

Turns the given string to lowercase. Same as s.toLowerCase()

lcase(s) :: s -> s

args	desc
`s`	String to lowercase.

lcase example

lcase 'aBcD'   # 'abcd'

match

Matches a regexp in a string. Same as s1.match(s2). The value returned is a special regexp match object.

match(s,m) :: s, RegExp -> [a]|null
match(m)(s) :: RegExp -> s -> [a]|null

args	desc
`s`	String to match in.
`m`	The match object which is interpreted as a RegExp.

match example

match 'a bar frog', '.'     # [ 'a', index: 0, input: 'a bar frog' ]
match 'a bar frog', 'fo'    # null
match 'a bar frog', /ar?/g  # ['a', 'ar']

replace

Returns a new string with occurences of a matching string/regexp with another string. Same as s1.replace(s2,s3)

replace(s,m,r) :: s, s|RegExp, s -> s
replace(r)(m)(s) :: s -> s|RegExp -> s -> s

args	desc
`s`	String to replace in.
`m`	The match object which can either be a string or a RegExp.
`r`	The replacement string where `m` matches.

replace example

replace 'abcab', 'b', 'c'    # 'accac'
replace 'abcab', 'd', 'c'    # 'abcab'
replace 'abcab', /a./g, 'f'  # 'fcf'

search

Searches the string for a given regexp and returns the index of the match. Same as s.search(m).

search(s,m) :: s, RegExp -> Number
search(m)(s) :: RegExp -> s -> Number

args	desc
`s`	String to search in
`m`	The match RegExp.

search example

search 'abc',  '.'    # 0
search 'abc',  /./    # 0
search 'abc',  /d/    # -1
search 'abc',  '.c'   # 1
findC = search('c')   # partial
findC 'aqdc'          # 3

split

Splits a string into an array divided on a separator. Same as s1.split(s2)

split(s,e) :: s, s|RegExp -> [s]
split(e)(s) :: s|RegExp -> s -> [s]

args	desc
`s`	String to split
`e`	Separator to split on which can be a string or RegExp.

split example

split 'abc', ''          # ['a','b','c']
split 'abc', 'b'         # ['a', 'c']
split 'cadabcab', /[ab]/ # ['c', 'd', '', 'c', '', '']

slice

Slice of a string s from m to n, same as s.slice(m,n).

Also applicable for array objects.

slice(s,m,n) :: s, n, n, -> s
slice(n)(m)(s) :: n -> n -> n -> s

args	desc
`s`	String/array to slice
`m`	Slice from
`n`	Slice to. Optional.

slice example

slice 'abcdef',  1, 3    # bc
slice [0,1,2,3], 1, 3    # [1,2]

drop

Slice the end of a string s from m, same as s.slice(m).

Also applicable for array.

drop(s,m) :: s, n, -> s
drop(m)(s) :: n -> n -> s

args	desc
`s`	String/array to slice end of
`m`	Slice from

drop example

drop 'abcdef',  2   # cdef
drop [0,2,3,4], 2   # [3,4]

take

Slice the beginning of a string s up to n, same as s.slice(0, n).

Also applicable for array.

take(s,n) :: s, n, -> s
take(n)(s) :: n -> n -> s

args	desc
`s`	String/array to slice beginning of
`n`	Slice up to

take example

take 'abcdef',  2    # ab
take [0,1,2,3], 2    # [0,1]

len

Length of string (or array)

Same as s.length.

len(s) :: s -> n

args	desc
`s`	String/array to get length of

len example

len 'abcd'   # 4
len [2,1]    # 2

trim

Trims whitespace off start and end of a string. Same as s.trim()

trim(s) :: s -> s

args	desc
`s`	String to trim.

trim example

trim '  ab  \n'    # 'ab'

ucase

Turns the given string to uppercase. Same as s.toUpperCase()

ucase(s) :: s -> s

args	desc
`s`	String to uppercase.

ucase example

ucase 'aBcD'  # 'ABCD'

Math functions

Functions for math.

and

Returns a function that performs logical and on the result. For coffeescript this function is aliased as aand.

aand(a1,a2) :: (*, *) -> Boolean
aand(a2)(a1) :: * -> * -> Boolean
aand(as...) :: (*, *, ...) -> Boolean

args	desc
`a1`	First argument to and.
`a2`	Second argument to and.
Variadic
`as`	Variable number of arguments to and.

and example

aand(true, true)      # true
aand(1,4)             # true
aand(1)(null)         # false

add

Adds two (or more) numbers or strings together.

add(a,b) :: a, a -> a
add(b)(a) :: a -> a -> a
add(as...) :: a... -> a

args	desc
`a`	First argument to add, number or string.
`b`	Second argument to add, number or string.
Variadic
`as`	Variable number of number/strings to add together.

both

Returns a function that wraps two (or more) functions and performs logical and on the result.

both(f1,f2) :: (a... -> Boolean), (a... -> Boolean) -> Boolean
both(f2)(f1) :: (a... -> Boolean) -> (a... -> Boolean) -> Boolean
both(fs...) :: (a... -> Boolean)... -> Boolean

args	desc
`f1`	First function to wrap.
`f2`	Second function to wrap.
Variadic
`fs`	Variable number of functions to wrap.

both example

gt10  = gt(10)
even  = (a) -> a % 2 == 0
lt100 = lt(100)
f     = both(gt10, even)
f(102)                        # true
g     = both(gt10, even, lt100)
g(102)                        # false

comp

Returns a function does a logical not on the result of the initial function.

comp(f) :: (a... -> Boolean) -> Boolean

args	desc
`f`	The function to not.

comp example

even  = (a) -> a % 2 == 0
odd   = comp(even)
odd(11)            # true

div

Division. a divided by b.

div(a,b) :: a, a -> a
div(b)(a) :: a -> a -> a
div(as...) :: a... -> a

args	desc
`a`	Dividend.
`b`	Divisor.
Variadic
`as`	Variable number of arguments. I.e. `div(a,b,c)` is `a / b / c`.

either

Returns a function that wraps two (or more) functions and performs logical or on the result. For coffeescript this function is aliased as either.

either(f1,f2) :: (a... -> Boolean), (a... -> Boolean) -> Boolean
either(f2)(f1) :: (a... -> Boolean) -> (a... -> Boolean) -> Boolean
either(fs...) :: (a... -> Boolean)... -> Boolean

args	desc
`f1`	First function to wrap.
`f2`	Second function to wrap.
Variadic
`fs`	Variable number of functions to wrap.

either example

gt10  = gt(10)
even  = (a) -> a % 2 == 0
lt100 = lt(100)
f     = either(gt10, even)
f(102)                        # true
g     = either(gt10, even, lt100)
g(102)                        # true

eq

Equality test. a equal to b, strict (as in === in javascript-terms). See also eql.

eq(a,b) :: a, a -> a
eq(b)(a) :: a -> a -> a
eq(as...) :: a... -> a

args	desc
`a`	Argument 1.
`b`	Argument 2.
Variadic
`as`	Variable number of arguments. I.e. eq(a,b,c)`is`a == b == c`.

gt

Greater than. a greater than b.

gt(a,b) :: a, a -> Boolean
gt(b)(a) :: a -> a -> Boolean

args	desc
`a`	First argument in `a > b`.
`b`	Second argument in `a > b`.

gte

Greater than or equals. a greater than or equals b.

gte(a,b) :: a, a -> Boolean
gte(b)(a) :: a -> a -> Boolean

args	desc
`a`	First argument in `a >= b`.
`b`	Second argument in `a >= b`.

lt

Less than. a less than b.

lt(a,b) :: a, a -> Boolean
lt(b)(a) :: a -> a -> Boolean

args	desc
`a`	First argument in `a < b`.
`b`	Second argument in `a < b`.

lte

Less than or equals. a less than or equals b.

lte(a,b) :: a, a -> Boolean
lte(b)(a) :: a -> a -> Boolean

args	desc
`a`	First argument in `a <= b`.
`b`	Second argument in `a <= b`.

max

The max of two (or more) arguments. Same as Math.max(a,b).

max(a,b) :: a, a -> Boolean
max(b)(a) :: a -> a -> Boolean
max(as...) :: a... -> Boolean

args	desc
`a`	First argument in `Math.max(a,b)`
`b`	Second argument in `Math.max(a,b)`
Variadic
`as`	Variable number of arguments. I.e `Math.max(a,b,c)`

min

The min of two (or more) arguments. Same as Math.min(a,b).

min(a,b) :: a, a -> Boolean
min(b)(a) :: a -> a -> Boolean
min(as...) :: a... -> Boolean

args	desc
`a`	First argument in `Math.min(a,b)`
`b`	Second argument in `Math.min(a,b)`
Variadic
`as`	Variable number of arguments. I.e `Math.min(a,b,c)`

mod

Modulus (javascript style). a modulus b.

mod(a,b) :: a, a -> a
mod(b)(a) :: a -> a -> a
mod(as...) :: a... -> a

args	desc
`a`	Dividend.
`b`	Divisor.
Variadic
`as`	Variable number of arguments. I.e. `mod(a,b,c)` is `a % b % c`.

mul

Multiplication. a multiplied by b.

mul(a,b) :: a, a -> a
mul(b)(a) :: a -> a -> a
mul(as...) :: a... -> a

args	desc
`a`	First factor in `a * b`.
`b`	Second factor in `a * b`.
Variadic
`as`	Variable number of arguments. I.e. `mul(a,b,c)` is `a * b * c`.

not

Function that does a logical not argument. For coffeescript this function is aliased as nnot.

nnot(a) :: * -> Boolean

args	desc
`a`	The argument to not.

not example

not(1)       # false
not(null)    # true

or

Function that performs logical or on the arguments. For coffeescript this function is aliased as oor.

oor(a1,a2) :: (*, *) -> Boolean
oor(a2)(a1) :: * -> * -> Boolean
oor(as...) :: (*, *, ...) -> Boolean

args	desc
`a1`	First argument to or.
`a2`	Second argument to or.
Variadic
`as`	Variable number of arguments to or.

or example

oor(1,0)         # true
oor(0,0)         # false
oor(0, null)     # false
oor(null)(1)     # true

sub

Subtraction. a subtracted by b.

sub(a,b) :: a, a -> a
sub(b)(a) :: a -> a -> a
sub(as...) :: a... -> a

args	desc
`a`	Minuend.
`b`	Subtrahend.
Variadic
`as`	Variable number of arguments. I.e. `sub(a,b,c)` is `a - b - c`.

Files

api.md

Latest commit

History

api.md

File metadata and controls

API

Type functions

I

isdef

isdef example

isplain

isplain example

type

type example

typeis

typeis example

Function functions

always

always example

apply

apply example

arity

unary

binary

ternary

arity example

arityof

arityof example

call

call example

compose

compose example

cond

cond example

curry

curry example

converge

converge example

flip

flip example

iif

iif example

maybe

maybe example

nth

nth example

once

once example

pall

pall example

partial

partial example

partialr

partialr example

pfail

pfail example

pipe

pipe example

plift

plift example

tap

tap example

unapply

unapply example

Object functions

clone

clone example

evolve

evolve example

eql

get

get example

has

has example

keys

keys example

keyval

keyval example

merge