o.coffee

ø is a library that eases functional programming in JavaScript and CoffeeScript. It contains common generic functions such as id, map and foldl. All functions in ø are pure functions.

At the moment, ø only supports using it with Node.js. Contributions are more than welcome!

 
             		           
                               
                            
                                
               
ø takes a function and a variable number of arguments, and
returns a new function with those arguments bound to the first
arguments of the given function.



var logAll = ø.curry(ø.map, console.log);

             		                            
ø = (f, args...) -> (args_...) -> f(args..., args_...)
             		           
                               
                            
                                
               
Identity functions
             		                            
             		           
                               
                            
                                
               
id returns its argument.
             		                            
ø.id = (x) -> x
             		           
                               
                            
                                
               
list returns a list of the given arguments.



ø.list(1, 2, 3) # => [1, 2, 3]




This function is an alternative to new Array(), which behaves
differently when it is given only one argument.
             		                            
ø.list = (xs...) -> xs
             		           
                               
                            
                                
               
Generic higher-order functions
             		                            
             		           
                               
                            
                                
               
flip takes a binary function and returns a new function with
the arguments interchanged.
             		                            
ø.flip = (f) -> (x, y) -> f(y, x)
             		           
                               
                            
                                
               
curry is identical to ø
             		                            
ø.curry = ø
             		           
                               
                            
                                
               
apply applies the given arguments to the given function.
             		                            
ø.apply = (f, args...) -> f(args...)
             		           
                               
                            
                                
               
comp returns a new function by composing the two given
functions.
             		                            
ø.comp = (f, g) -> (args...) -> f(g(args...))
             		           
                               
                            
                                
               
Manipulating lists
             		                            
             		           
                               
                            
                                
               
unshift returns a new list by prepending the first argument.
             		                            
ø.unshift = (x, xs) -> ø.list(x, xs...)
             		           
                               
                            
                                
               
head returns the first element of the list.
             		                            
ø.head = (xs) -> xs[0]
             		           
                               
                            
                                
               
tail returns the list sans its first element.
             		                            
ø.tail = (xs) -> xs[1..]
             		           
                               
                            
                                
               
last returns the last element of the list.
             		                            
ø.last = (xs) -> xs[xs.length - 1]
             		           
                               
                            
                                
               
init returns the list sans its last element.
             		                            
ø.init = (xs) -> xs[..xs.length - 2]
             		           
                               
                            
                                
               
null returns true iff the list is empty.
             		                            
ø.null = (xs) -> xs.length is 0
             		           
                               
                            
                                
               
elem returns true iff the first argument occurs in the list.
             		                            
ø.elem = (x, xs) -> ø.any(ø.curry(ø.eq, x), xs)
             		           
                               
                            
                                
               
length returns the length of the list.
             		                            
ø.length = (xs) -> xs.length
             		           
                               
                            
                                
               
glue concatenates two lists.
             		                            
ø.glue = (xs, ys) -> ø.list(xs..., ys...)
             		           
                               
                            
                                
               
map applies a function to all elements of the list, returning
a new list with the return values of the function.
             		                            
ø.map = (f, xs) -> f(x) for x in xs
             		           
                               
                            
                                
               
filter returns a list of all the elements in the given list for
which the given function returns true.
             		                            
ø.filter = (f, xs) -> x for x in xs when f(x)
             		           
                               
                            
                                
               
land returns true iff all elements in the list are true.
             		                            
ø.land = (xs) ->
    for x in xs
        return false unless x
    true
             		           
                               
                            
                                
               
lor returns true if at least one element in the list is true.
             		                            
ø.lor = (xs) -> not ø.null(ø.filter(ø.id, xs))

ø.all = (f, xs) -> ø.comp(ø.land, ø.curry(ø.map, f))(xs)

ø.any = (f, xs) -> ø.comp(ø.lor, ø.curry(ø.map, f))(xs)
             		           
                               
                            
                                
               
Folding
             		                            
             		           
                               
                            
                                
               
foldl does a left-associative fold of a structure.
             		                            
ø.foldl = (f, z0, xs0) ->
    lgo = (z, xs) ->
        if ø.null(xs) then z
        else lgo(f(z, ø.head(xs)), ø.tail(xs))
    lgo(z0, xs0)
             		           
                               
                            
                                
               
foldl1 is the same as foldl except it uses the head of the
list as the initial value.
             		                            
ø.foldl1 = (f, xs) -> ø.foldl(f, ø.head(xs), ø.tail(xs))
             		           
                               
                            
                                
               
foldl does a right-associative fold of a structure.
             		                            
ø.foldr = (f, z, xs) ->
    go = (ys) ->
        if ys.length is 0 then z
        else f(ø.head(ys), go(ø.tail(ys)))
    go(xs)
             		           
                               
                            
                                
               
foldr1 is the same as foldr except it uses the head of the
list as the initial value.
             		                            
ø.foldr1 = (f, xs) ->
    if xs.length is 1
        ø.head(xs)
    else
        f(ø.head(xs), foldr1(f, ø.tail(xs)))
             		           
                               
                            
                                
               
sum and product are pretty self-explanatory.
             		                            
ø.sum = (xs) -> ø.foldl1(ø.add, xs)
ø.product = (xs) -> ø.foldl1(ø.multiply, xs)
             		           
                               
                            
                                
               
reverse reverses the given list.
             		                            
ø.reverse = (xs) -> ø.foldl(ø.flip(ø.unshift), [], xs)
             		           
                               
                            
                                
               
concat concatenates the lists in the given list.



ø.concat([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    # => [1, 2, 3, 4, 5, 6, 7, 8, 9]

             		                            
ø.concat = (xss) -> ø.foldr(ø.glue, [], xss)

ø.concatMap = (f, xs) -> ø.foldr(ø.comp(ø.glue, f), [], xs)
             		           
                               
                            
                                
               
Basic mathematics
             		                            
             		           
                               
                            
                                
               
succ and pred respectively return the successor and
predecessor of the given value.
             		                            
ø.succ = (x) -> x + 1
ø.pred = (x) -> x - 1
             		           
                               
                            
                                
               
even and odd return whether their arguments are even or odd,
respectively.
             		                            
ø.even = (a) -> a % 2 is 0
ø.odd = (a) -> a % 2 isnt 0
             		           
                               
                            
                                
               
Operators
             		                            
             		           
                               
                            
                                
               
These functions map to JavaScript's operators. They are useful in
certain higher-order situations. For example, if you want to compare
all elements in a list and return a new list of Booleans, you can use
eq



ø.map(ø.curry(ø.eq, 42), my_list)

             		                            
ø.and = (a, b) -> a and b
ø.or = (a, b) -> a or b
ø.not = (a) -> not a

ø.add = (a, b) -> a + b
ø.subtract = (a, b) -> a - b
ø.multiply = (a, b) -> a * b
ø.divide = (a, b) -> a / b
ø.mod = (a, b) -> a % b
ø.negate = (a) -> -a

ø.eq = (x, y) -> x is y
ø.neq = (x, y) -> x isnt y
ø.gt = (x, y) -> x > y
ø.gte = (x, y) -> x >= y
ø.lt = (x, y) -> x < y
ø.lte = (x, y) -> x <= y

module.exports = ø