Nonlinear Performance Magnification

    pun

    0.1.1 • Public • Published

    Pun

    A tiny functional programming library for Javascript/Coffeescript.

    Now availiable on NPM!

    Currying

    pun.curry allows you to partially apply some values to a function:

    = (a,b,c,d) ->
        [a,b,c,d].join('')
     
    fab = pun.curry f12
     
    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(12)
     
    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:  []
     
    = List.Cons(1List.Cons(2List.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:

    = 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._
     
    = 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
     
    = 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 
     
    = 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:

    = pun.match(
        $('a')-> "Got: #{@a}"
    )

    Finally, you can bind to patterns:

    = 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.$
     
    = 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.$
     
    = pun.match(
        {a: 0b: "lol"},          -> "One"
        {a: 0b: $('n',Number)},  -> "Two #{@n}"
        {a: 0},                    -> "Three"
    )
     
    f({a:0})               # "Three" 
    f({a:0b:"lol"c:1}) # "One" 
    f({a:0b: 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 1List.Cons 2List.Cons 3List.Nil())  # [1,2,3] 

    Install

    npm i pun

    DownloadsWeekly Downloads

    5

    Version

    0.1.1

    License

    none

    Last publish

    Collaborators

    • crogers