Pun
A tiny functional programming library for Javascript/Coffeescript.
Now available on NPM!
Currying
pun.curry allows you to partially apply some values to a function:
f = (a,b,c,d) ->
[a,b,c,d].join(', ')
fab = pun.curry f, 1, 2
fab(3,4) # 1, 2, 3, 4
fab("c", "d") # 1, 2, c, d
pun.autocurry allows you to create functions which automatically curry when you apply arguments to them:
# Using f from previous example
autof = pun.autocurry f
autofab = autof(1, 2)
autofab(3,4) # 1, 2, 3, 4
autofab("c", "d") # 1, 2, c, d
Abstract Data Types
You can use ADTs like so:
List = pun.ADT
Cons: ['value', 'next']
Nil: []
l = List.Cons(1, List.Cons(2, List.Nil())) # Linked list for [1,2]
l.value # 1
l.next.value # 2
And can apply pattern matching!
Pattern Matching
Pun allows for complex pattern matching in javascript/coffeescript. Let's dive in with an example:
Hello, factorial
Coffeescript
$ = pun.$
fac = pun.match(
0, -> 1
$, (n) -> n * fac (n-1)
)
Javascript
var $ = pun.$
var fac = pun.match(
0, function() { return 1 }, // Note required comma at end of line
$, function(n){ return n * fac(n-1) }
)
This is equivalent to the Haskell:
fac 0 = 1
fac n = n * fac (n-1)
pun.match takes pairs of arguments, the first being the pattern the second being the function applied if the pattern is matched. It will return undefined if there is no match.
Basic Matching
Numbers, strings, bools and undefined/nulls are all matched simply by equality:
f = pun.match(
110, -> "one"
"foobar", -> "two"
true, -> "three"
)
f(110) # "one"
f("foobar") # "two"
f(true) # "three"
Wildcard
The wild character pun._ can be used to match any value:
_ = pun._
f = pun.match(
0, -> 0
1, -> 1
_, -> "Other"
)
f(0) # 0
f(1) # 1
f("foobarbaz") # "Other"
Type Matching
You can pass functions which will be interpreted as type constructors - this allows you to match your own "classes" or the builtin ones:
class Cat
f = pun.match(
Number, -> "Number"
String, -> "String"
Boolean, -> "Boolean"
Cat, -> "Cat"
)
f(1024) # "Number"
f("foobar") # "String"
f(true) # "Boolean"
cf(new Cat()) # "Cat"
Binding
The $ symbol can be used to 'bind' values so that you can use them in the matching function. You can use it without an argument and the bound value will be passed to match function as an argument, or with an argument of a pattern to match:
$ = pun.$ # alias $ so we can use it more easily
f = pun.match(
$(Number), (n) -> "Num: #{n}"
$, (a) -> "Got: #{a}"
)
f(0) # "Num: 0"
f(true) # "Got: true"
f({}) # "Got: [object Object]"
Or you can supply it with a string s and it will be avaliable in this.s/@s of the match function:
f = pun.match(
$('a'), -> "Got: #{@a}"
)
Finally, you can bind to patterns:
f = pun.match(
$('a',Number), -> "Got: #{@a}"
)
f(1) # "Got 1"
f(false) # undefined
Arrays
Arrays will be matched item by item and each element of the array is a pattern. The pattern array length and the value array length must be the same.
$ = pun.$
f = pun.match(
[1,2,3], -> "onetwothree"
[$, $('a'), $('b', Number)], (first) -> "#{first}, #{@a}, #{@b}"
)
f([0,"lol",2]) # "0, lol, 2"
f([0,"lol",true]) # undefined
f([1,2,3]) # "onetwothree"
f([1,2,3,4]) # undefined
Objects
Objects as a pattern will match each key and value. The value of each key/value pair is a pattern:
$ = pun.$
f = pun.match(
{a: 0, b: "lol"}, -> "One"
{a: 0, b: $('n',Number)}, -> "Two #{@n}"
{a: 0}, -> "Three"
)
f({a:0}) # "Three"
f({a:0, b:"lol", c:1}) # "One"
f({a:0, b: 4}) # "Two 4"
Abstract Data Types
ADTs can also be matched:
$ = pun.$
from = pun.match(
List.Nil(), -> []
List.Cons($, $), (x, xs) -> [x].concat from(xs)
)
from(List.Cons 1, List.Cons 2, List.Cons 3, List.Nil()) # [1,2,3]