pmatch-js

Powerful pattern matching for js - inspired by Haskell.

Install

npm install pmatch-js

Testing

Run npm test - requires chai and mocha

Examples

Notes:

• The otherwise call is necessary and must be the last call that you make.
• '_' acts as a wildcard. I liked the smiley :-)
• Its implemented via recursion. Just that you know.
• uses ES6 syntax.

Calculate fibonacci

const fibbonacci = n => {
        const go = (n, a, b) => match(n)
                .when(0, a)
                .otherwise(_ => go(n - 1, b, a +b));

        return go(n, 0, 1);
}

console.log(fibbonacci(25));
// 75025

Calculate factorial

const factorial = n => match(n)
        .when(0, 1)
        .otherwise(n => n * factorial(n - 1));

console.log(factorial(10))
// 3628800

list length

const tail = ([_, ...xs]) => xs;
const head = ([x, ..._]) => x;

const count = c => match(c)
        .when([], 0)
        .otherwise(xs => 1 + count(tail(xs)));

console.log(count([1,2,3,4,5]));
// 5

Map f over a list

const map = (f, xs) => match(xs)
        .when([], [])
        .otherwise(([x, ...xs]) => [f(x), ...map(f, xs)]);

console.log(map(Number, ['1', '2', '3', '4', '5']));
[ 1, 2, 3, 4, 5 ]

Recursive zipWith

const zipWith = (f, lst1, lst2) => match([lst1, lst2])                                                           
        .when([[], '_'], [])                                                                                     
        .when(['_', []], [])                                                                                     
        .otherwise(([[x, ...xs], [y, ...ys]]) => [f(x, y)].concat(zipWith(f, xs, ys)));                          
                        
console.log(zipWith((a, b) => a + b, [4,2,5,6], [2,6,2,3]));                                                     
// [ 6, 8, 7, 9 ]
                        
console.log(zipWith((a, b) => `${a} ${b}`, ['foo', 'bar', 'baz'], ['fighters', 'hoppers', 'aldrin']));           
// [ 'foo fighters', 'bar hoppers', 'baz aldrin' ]
                
console.log(zipWith(Math.max, [6,3,2,1], [7,3,1,5]));
// [ 7, 3, 2, 5 ]]

Walk-a-tree / map f over Tree

class Tree {
        constructor(left, right) {
                this.left = left;
                this.right = right;
        }
}

class Node {
        constructor(value) {
                this.value = value;
        }
}

const T = (l, r) => new Tree(l, r);
const N = v => new Node(v);

const walkT = t => match(t)
        .when(Node, v => console.log(v.value))
        .when(Tree, t => { walkT(t.left); walkT(t.right)})
        .otherwise(_ => 'error');
        
const mapT = (f, t) => match(t)
        .when(Node, v => N(f(v.value)))
        .when(Tree, t => T(mapT(f, t.left), mapT(f, t.right)))
        .otherwise(_ => { throw new Error('error') });

const pow = v => Math.pow(v, 2);

const mapped = mapT(pow, T(T(N(5), T(N(7), N(1))), T(N(-1), N(8))));

walkT(mapped);
// 25
// 49
// 1
// 1
// 64

Some deeper patterns: Note: 'string' and 'number' are the typeof's. So we can match on those as well...

const m1 = match('Hello')
    .when('string', a => [true, a.toUpperCase()])
    .when('number', a => [false, a])
    .otherwise(_ => [false, 'no match'])

L(m1);

const m2 = match(['Hello', 5])
    .when(['string', 'string'], ([a, b]) => [false, a, b])
    .when(['string', 'number'], ([a, b]) => [true, a, b])
    .otherwise(_ => [false, 'no match'])

L(m2);

some more difficult ones:

const m5 = match(['Hello', [100, 100], 100])
    .when(['Hello', [5, 5], '_'], ([a, b, c]) => [false, a, b, c])
    .when(['Hello', [100, 100], p => p < 100], ([a, b, c]) => [false, a, b, c])
    .when(['Goodbye', ['_', '_'], '_'], ([a, b, c]) => [false, a, b, c])
/* -> */.when(['_', [100, 100], p => p === 100], ([a, b, c]) => [true, a, b, c])
    .otherwise(_ => [false, 'no match'])

L(m5);

const anyObject = {
    a: 5,
    b : {
        c: 4
    }
};

const m7 = match(anyObject)
    .when({a : 5}, false)
    .when({a : 5, b : { c : 3 }}, false)
    .when({a : 5, b : { c : '_' }}, true)
    .otherwise(false);

Can also match own types in nested arrays:

class ABox {
    constructor(v) {
        this.v = v;
    }
}

const m6 = match([new ABox(5), [new ABox(10), new ABox(20)]])
    .when([ABox, 5], ([a, b]) => [false, a, b])
    .when([ABox, [ABox, ABox]], ([a, b]) => [true, a, b])         // <- will match
    .otherwise(_ => 'no match');

L(m6);