

Show HN: Matches.js -- Powerful Pattern Matching for Javascript - natefaubion
https://github.com/natefaubion/matches.js

======
jpolitz
Cool! Sucks that it has to be so stringly typed, but I can't see another
alternative.

One concern:

"Each pattern will be tried in order until a match is found."

As far as I know, ECMAScript doesn't specify any enumerations on objects that
obey an order... browsers do syntactic order, but it's by no means a
guarantee. (e.g. <http://stackoverflow.com/a/280861>)

~~~
natefaubion
You are correct. There is not a guarantee for the future, though I doubt this
behavior will change for V8 (this is currently node only). If that scares you,
you can use the combinator syntax (check out the readme towards the bottom).
The object literal syntax is just sugar for using combinators.

edit: BTW, if you want some precedence in a major library relying on this
behavior, look no further than Backbone's router, specifically the
`_bindRoutes` method.

------
OmarIsmail
I didn't know I needed this until I saw it and had that A-HA moment when I
realized how much cleaner this would make a lot of code. Instead of hiding
away the logic in a bunch of conditionals this makes the overloading
declarative which is great for maintenance.

------
username3
What are some applications of pattern matching?

~~~
tlack
You know how a lot of jQuery functions take either a string, or a function, or
an array of strings, etc? Instead of making those decisions in your code in a
series of IF statements, you could use this library and just maintain a "map"
of the different argument forms and have this library dispatch the right
option.

In Erlang, this is used all the time to make functions that behave differently
depending on how they're called - for instance, massaging a binary string into
a regular string if the function only expects a regular string.

This is a small tool in a programmer's toolkit, but could be a handy one.

------
ntoshev
I've played a bit with pattern matching as a DSL on top of JavaScript:
<http://jsfiddle.net/ntoshev/q8Ayw/1/>

------
se85
I've come across aspects of this functionality before in a couple of languages
now, even psql, however looking at this JavaScript way of doing it, I have to
question whether it helps code readability or hurts it.

edit: dyslexia

~~~
natefaubion
Take a look at the next sentence: "Keep in mind, that time is measured in the
single microseconds (1µs vs 3µs) to dispatch 5 calls to the same function."

So you are still looking at sub-microsecond dispatch time for a single call.
If you look at benchmark/compare.js you'll see how much shorter and clearer
the pattern matched function is. I doubt this will put a strain on your
performance.

edit: That said, there is likely room for optimizations and speed improvement.
It will naturally take longer because it has the overhead of making function
calls to the various pattern functions to check if there's a match, instead of
having it all inlined like in the hand optimized function.

edit2: Sorry, this was in response to another comment that looks like it got
deleted while I was editing. Now its attached itself elsewhere.

~~~
se85
Thanks, I misread the first time, made sense the second time! My mistake!

I still have my doubts as to how readable such an approach like this would be
in large JavaScript application's when taking into account the already very
dynamic nature of JavaScript, but thats more of a personal opinion than
anything else.

------
pooriaazimi
For those interested: XRegExp (<http://xregexp.com>) is also relevant.

(Not a direct competitor to Matches.js, but has some nice features)

------
danh
Something like this would make a great addition to CoffeeScript.

~~~
natefaubion
It meshes pretty well as is. If only I could get rid of the strings and
redundant arguments.

    
    
      mymap = pattern {
        '_, []' : -> []
        'f, [x, xs...]' : (f, x, xs) -> 
          [f x].concat mymap(f, xs)
      }
    

It shares a lot of the same splat/rest/destructuring syntax.

~~~
oscilloscope
Check out LiveScript's implicit switch syntax:

<http://gkz.github.com/LiveScript/#switch>

~~~
natefaubion
That's along similar lines, but more like guards in Haskell:
<http://en.wikibooks.org/wiki/Haskell/Control_structures>

------
elliotlai
i want this in js for a long time

------
dreamdu5t
Awesome! This is so useful!

