fnMatch

This is a very simple implementation of pattern matching using no syntax extensions. That means you can use it without a transpiler; just include it on your project/website.

Quick example:

You can do this in OCaml:

let rec fib n = match n with
  | 0 -> 1
  | 1 -> 1
  | x -> fib (x-2) + fib (x-1)

JavaScript using fnMatch:

let fib = (n) =>
  match(n)(
    (x = 0) => 1,
    (x = 1) => 1,
    (x) => fib(x - 2) + fib(x - 1)
  );

Installation

• node

npm i fnMatch

• web

<script src="https://raw.githubusercontent.com/mrkev/fnMatch/master/dist/fnMatch.js"></script>

Usage

Instead of extending the language, it just uses functions. That's it. Just import fnMatch anywhere:

const { match, func } = require("fnMatch");

It supports:

• Shape matching through object deconstruction:

let group = {
  course: "CS 3410",
  members: [
    { name: "Ajay", age: 22 },
    { name: "Seung", age: 23 },
    { name: "Adi", age: 22 },
  ],
};

match(group)(
  ({ club, members }) => {}, // doesn't match, missing "club"
  ({ course, members: [first, ...rest] }) => {}, // matches!
  ({ course, members }) => {} // would match if previous didn't
);

• Value matching through default value syntax:

match("hello")(
  (_ = "hey") => {}, // doesn't match
  (_ = "world") => {}, // doesn't match
  (_ = "hello") => {} // matches!
);

• Binding (of course, these are functions after all!)

match({ name: "Ajay" })(
  ({ name }) => conosle.log(`Hello ${name}!`), // matches, name is "Ajay"
  () => console.log("Hello, someone!") // would match if previous didn't
);

• Alternative syntax: pattern definition before evaluation:

func(
  ({ name }) => conosle.log(`Hello ${name}!`), // matches, name is "Ajay"
  () => console.log("Hello, someone!") // would match if previous didn't
)({ name: "Ajay" });

Woah woah woah. Why would I want to do a pattern match by defining the patterns first and passing in the value later? Well, because this is an expression, and this way of doing things is useful for defining functions, a la OCaml's function keyword:

OCaml:

let rec fib = function
  | 0 -> 1
  | 1 -> 1
  | x -> fib (x-2) + fib (x-1)

JavaScript:

let fib = func(
  (_ = 0) => 1
  (_ = 1) => 1
  (x) => fib(x-2) + fib(x-1)
);

• And of course, "match" and "func" are expressions evaluating to the return the value of the matched function. Here's a more complex example:

const process_response = func(
  ({ status: s = 200, data: d = null }) => Error("Data is null"),
  ({ status: s = 200, data: d = [] }) => Error("Data is empty"),
  ({ status: s = 200, data }) => data, // return data
  ({ errors: [h, ...t] }) => Error(`Non-empty errors. ${t.length + 1} total.`),
  ({ status }) => Error(`Status ${status}, no errors reported`),
  (_) => Error("Invalid response")
);

const print_response = (response) => {
  const result = process_response(response);
  if (result instanceof Error) throw result;
  console.log(`Recieved ${result}!`);
};

Things to note

• Patterns are tested in order, from top to bottom:

// This prints "default"
match({ name: "Ajay" })(
  (_) => console.log("default"),
  ({ name }) => console.log(name)
);

// This prints "Ajay"
match({ name: "Ajay" })(
  ({ name }) => console.log(name),
  (_) => console.log("default")
);

• () => {} matches undefined, not all (aka, () => {} !== (_) => {}):

// This prints "undefined"
match()(
  () => console.log("undefined"),
  (_) => console.log("anything")
);

// This prints "anything"
match(3)(
  () => console.log("undefined"),
  (_) => console.log("anything")
);

• Array semantics are a little different from how JavaScript normally works:

Array semantics

For the sake of usability, the semantics used for array matching are different from how calling a function with that destructs an array would have you believe. Let's illustrate with 2 examples:

• Identifiers will always match a value in the array, whereas on function calls they are assigned undefined if there's nothing for them to match

// Javascrpt
(([x, ...y]) => console.log(x, y))([]); // logs "undefined []"

// fnMatch
func(([x, ...y]) => console.log(x, y))([]); // logs nothing, doesn't match

• Patterns without a "rest clause" (ie, ...t) will only match patterns of that same length (similar to how Ocaml works)

// Javascrpt
(([x, y]) => console.log(x, y))([1, 2, 3]); // logs "1 2"

// fnMatch
func(([x, y]) => console.log(x, y))([1, 2, 3]); // logs nothing, doesn't match

Disclaimer

This was very quickly thrown together, so it's very much not optimized in any way. See the source for details on maybe not low-hanging, but definitley juicy performance improvements that could be made.

Happy matching!

---