Skip to content
/ fnMatch Public

JavaScript pattern matching without transpiling (just import and go)

Notifications You must be signed in to change notification settings

mrkev/fnMatch

Repository files navigation

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!


Build Status Coverage Status

About

JavaScript pattern matching without transpiling (just import and go)

Resources

Stars

Watchers

Forks

Packages

No packages published