optima

I think of full-featured pattern matching as a fairly recent addition even to Lisp. Lisp has had some pattern-matching constructs forever of course (cond, destructuring-bind, Norvig's sexp matcher from PAIP [1], etc.). But it's only with the more recent emergence of optima [2] as a de-facto standard that it now has really good pattern matching. It was probably the #1 thing I missed in Lisp, after having used ML a bit, until optima came along. [1] https://github.com/norvig/paip-lisp/blob/master/lisp/patmatc... [2] https://github.com/m2ym/optima

Likewise, Common Lisp has a powerful matching DSL library too - Optima[0]. I also found a pretty new alternative, Trivia[1], which claims to be a drop-in replacement for Optima, but more extensible. -- [0] - https://github.com/m2ym/optima [1] - https://github.com/guicho271828/trivia

There is one for Common Lisp too https://github.com/m2ym/optima

Lisp doesn't have pattern matching. With optima[0] it does. Lisp uses prefix notation. With mexpr[1] it uses infix notation. And so on. [0] https://github.com/m2ym/optima [1] https://github.com/tmccombs/mexpr

It's things like this that remind me that Lisp(s) are really the best languages for taking advantage of the idea of Turing completeness. In terms of ease of implementation that is. I think that really, this is what we mean by "powerful" languages - how easily can you take advantage of the principle of completeness to do anything in your chosen language. You often hear people using the idea of completeness to say that their favourite language can, of course, do anything. But in reality some languages just aren't very well suited to it, or would require some horrendous amount of coding and abstractions (Greenspuns Tenth rule comes to mind [1]). So whenever some new idea in programming becomes popular, whether it's pattern matching [2], concurrency [3], or even the web (HN), you can always rest easy because someone will be able to quite q

No syntactic sugar needed. In most lisp pattern matching libraries there are higher level matchers such as "list" etc. Just as the first element of a list is a function or special operator in normal context, in a pattern matching context the first element is a matcher. You can even define new matchers if you want, just like you can define new functions. This makes pattern matching libraries in lisp more powerful than the built-in pattern matching of Haskell and other functional languages. I just looked at TFA and yes, it's truly awful. It doesn't have to be that way. See e.g. https://github.com/m2ym/optima (a pattern matching library for common lisp). I haven't tried it, but I've tried the predecessor of that library.