pattern matching in JS

Nic Volanschi nic.volanschi at
Sat Aug 11 12:29:59 PDT 2012

On Wed Jul 4 08:01:43 PDT 2012 Brendan Eich brendan at
> If only JS had pattern matching!

On Mon Jul 9 09:19:54 PDT 2012 Russell Leggett russell.leggett at wrote:
> I know that full blown patterns are out of scope (though I'm hoping maybe
> this discussion might change that), but even if we can't have it now, I
> think irrefutable destructuring would really make people see the potential.

Actually, pattern matching *can* be implemented in the current JS language, as 
a very simple library [1] of 150 lines of JS (plus more 150 lines of optimizations).
The library can be tested online in any browser with no extra installation, at 
the following address [2]:
The implementation and the matching concepts are completely described in a
recent paper [3].

Of course, this library-based implementation is inferior to the kind of language 
support being discussed for Harmony, as it implies some notational overheads.
For instance, when in Harmony (as currently foreseen) you would write:

 let [x...l] = [1,2,3];

to bind x=1 and l=[2,3], using the library you would have to call 
a "match" function like this:

 let s = match([1,2,3], "[%x|%l]");

which binds s={x:1,l:[2,3]}. 
(As you may see, in the current implementation, "|" is used instead 
of "..." and variables in the pattern are prefixed by "%", but these 
can be changed easily - the notation language can in fact be customized 

Thus, the notational overheads (apart the above accidental diffs) are:
- putting quotes around the pattern to make it a string, 
- explicitly calling the match function and storing its results in s, and
- getting x and l rather as s.x and s.l

Nevertheless, I think that this (modest) prototype could serve discussions about
future patterns in JS in the following ways:

1. by offering a playground for different pattern dialects in today's JS, 
which can be better than discussing them only on paper examples, until fully 
implemented in the language. Indeed, by studying the straightforward implementation [1],
one can see that every notation (e.g. the arrays notation) can be changed by simply
modifying one single function (Array.prototype.matches() in this case).

2. by introducing (in [3]) a simple conceptual framework in which the meaning 
of a pattern can be cleanly defined. Moreover, this meaning applies to all of: 
destructuring patterns, binding patterns and refutable patterns. This is a bit similar
to the (elegant!) factorized definition of refutable and irrefutable patterns in 
the strawman:pattern_matching, but additionnally separates the definitions of
array patterns, object patterns, and patterns for different kinds of literals,
instead of defining the meaning of all of them in a single recursive function.

I am of course available for further details for anyone finding this topics useful.


[1] The custom notations library:
[2] Try customized notations in JavaScript online:
[3] Pattern Matching for the Masses using Custom Notations.
    Science of Computer Programming 77:5 (2012) 609–635.

More information about the es-discuss mailing list