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)
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.
Multimethods would be an alternative to this type of ad-hoc polymorphism. I've encoded immutable multimethod environments in my new library, bilby.js:
https://github.com/pufuwozu/bilby.js
Lets you write things like this:
var env = λ.environment()
.method('length', λ.isArray, function(a) {
return a.length;
})
.method('length', λ.isString, function(s) {
return s.length;
})
.property('empty', function(o) {
return !this.length(o);
});
env.empty([]) == true;
env.empty([1, 2, 3]) == false;
Where isArray and isString are any functions that return true/false based on the input arguments. The environment then dispatches whichever method that has a predicate return true first.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.
edit: dyslexia
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.
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.
(Not a direct competitor to Matches.js, but has some nice features)
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."... [P]attern matching inspired by static languages is a particularly poor fit for JavaScript (and by extension CoffeeScript), because types are extremely weak in JS." -jashkenas [1]
"[... P]attern matching is not nearly as useful in a language without rich types [...]" - jashkenas [2]
I'm on that reddit thread, respectfully disagreeing with him.
[1]: https://github.com/jashkenas/coffee-script/issues/1419#issue...
[2]: http://www.reddit.com/r/programming/comments/er0qj/coffeescr...