Mutch

A simple pattern matching library to hold you over until the proposal gets merged

Installation

Use your favorite npm package manager to add mutch, then import match from it like so:

bun i mutch

then

import { match } from 'mutch'

Use

match takes in 3 parameters:

• value - the value to match on
• whens - an array of when-then tuples, where when is a value of the same type as value and then is a callback function optionally taking in value and returning anything
• otherwise - a default then

So, if you wanted to match on some json, it'd look something like this:

const coords = { x: 1, y: 2 }

match(coords,
  [
    [{ x: 1, y: 2 }, (c) => c.x],
    [{ x: 4, y: 8 }, (c) => c.y],
  ],
  () => 0
)

// output: 1

You can also fuzzy match on objects and arrays, with descending match priority:

const coords = { x: 1, y: 2 }

match(coords,
  [
    [{ y: 2 },       (c) => c.x],
    [{ x: 1 },       (c) => c.y],
    [{ x: 4, y: 8 }, (c) => c.y],
  ],
  () => 0
)

// output: 2

In the case of array fuzzy matching, order and sequence matters:

const array = [1, 2, 3, 4]

match(array,
  [
    [[1, 3], (a) => a[0]],
    [[2, 3], (a) => a[1]],
  ],
  () => 0
)

// output: 2

Why

One of the limitations I've run into with modern javascript is the lack of pattern matching, a feature I've loved about more functional languages. Sure, js has switch, but that's a statement, and so the result cannot be intuitively captured the way you would any other data. While I recognize this library can 100% be made redundant by just arranging your ifs in a certain pattern, the result is typically difficult to read or necessarily imperitive code. And I have enough of an issue with that that I wrote a library about it.

Basically:

• ternary chaining is hard to read -- an accessibility concern
• if blocks are imperative
• switch statements are imperative

as for why this library:

• it's reasonably functional under the hood
• it's like 50 lines
• it uses native, functional js syntax
• did I mention it's just a function?

Notes

• I created this with performance in mind, but with the ultimate goal that it should be ergonomic and organic, so json deep equality is not explicitly supported
• Matching on functions is currently not supported, simply because I can't imagine a scenario where that would be useful? Feel free to open a PR about it

Contributing

Feel free to open up a PR :D

License

Licensed under GPLv3