rematch
rematch copied to clipboard
Pattern matching for JavaScript / TypeScript
Rematch
Rematch is a pattern matching library built for JavaScript and TypeScript. Pattern matching helps you write safer, more readable, and more concise code.
Try it now
npm install rematch
Or download a release and pick up lib/rematch.js
.
Basic usage
function dangerLevel(mutant) {
return Rematch(mutant, [
Rematch.Type(Villain, () => 5),
Rematch.Value(Mutants.Flash, () => 0),
Rematch.Value(Mutants.Superman, () => 2)
]);
};
console.log([
dangerLevel(Mutants.Flash), // 0
dangerLevel(Mutants.Superman), // 2
dangerLevel(Mutants.Joker) // 5
])
console.log(dangerLevel(Mutants.Batman)) // Error: Rematch.MatchError
Play with it live on RunKit.
API
The Rematch
function takes in an argument and a group of cases to test the argument against.
There are 4 types of cases:
- Value - argument matches single value
- Values - argument matches one of multiple values
- Type - argument matches a type
- Else - argument does not match any previous cases
If no cases are valid, a Rematch.MatchError
is thrown. There are no 'fall-throughs' like in switch statements.
Advanced
By default, equality checks use lodash.isEqual
, which does a structural comparison. You can override this by setting
Rematch.isEqual
to a custom value.
Why use pattern matching over if/else?
For the large majority of code that isn't performance-sensitive, there are a lot of great reasons why you'd want to use pattern matching over if/else:
- it enforces a common return value and type for each of your branches (when using type definitions)
- in languages with exhaustiveness checks, it forces you to explicitly consider all cases and noop the ones you don't need
- it prevents early returns, which become harder to reason about if they cascade, grow in number, or the branches grow longer than the height of your screen (at which point they become invisible). Having an extra level of indentation goes a long way towards warning you you're inside a scope.
- it can help you identify logic to pull out, rewriting it into a more DRY, debuggable, and testable form.
A longer example
Let's do an example! We're building a webapp, and we need to authenticate our users and update them on their status. Here's a straightforward solution:
if(user instanceof BlacklistedUser) {
warnBlacklistMonitor();
return;
}
else if(user.password === enteredPassword) {
login();
alert("You're logged in!");
}
else {
onUserFailedLogin();
alert("Mistyped your password? Try again or do a password reset.");
}
This code works. Let's see how a pattern matching solution stacks up:
Rematch(user, [
Rematch.Type(BlacklistedUser, () => warnBlacklistMonitor()),
Rematch.Else(() => {
var statusMessage = Rematch(enteredPassword, [
Rematch.Value(user.password, () => {
login();
return "You're logged in!";
}),
Rematch.Else(() => {
onUserFailedLogin();
return "Entered password is invalid";
})
]);
alert(statusMessage);
})
])
It's immediately clear that there are 3 return points, and that 2 of them are dependent on the other one.
We've identified a common variable statusMessage
, which'll make debugging / testing easier down the line.
And lastly, all the return points consistently return nothing.