tamale

Pattern matching is going to be a hard sell in Java, because languages based around pattern matching place a much, much higher emphasis on values rather than identity. You need good data structure literals, and to have two things with the same content be interchangeable, not just two objects that currently happen to have the same fields. In other words, I think OOP and pattern matching are inherently antagonistic language features. They can coexist in a language (OCaml also has both), but not really in the same code. I figured this out working on a library for pattern matching in Lua (https://github.com/silentbicycle/tamale); Lua is less pervasively object-oriented, and uses literal "tables" (basically, JSON) quite a bit, so it's a better fit.

Unfortunately, Lua has statement- rather than expression-oriented semantics (i.e., no "implicit returns"). It's quite nice otherwise, though, and its integration with C is hard to beat. I wrote a library for pattern-matching in Lua, btw (http://github.com/silentbicycle/tamale). May be of interest.

FWIW, I wrote a pattern-matching library for Lua, Tamale (http://github.com/silentbicycle/tamale/). It was an interesting project, because almost everything I could find about implementing pattern-matching assumed the patterns could be analyzed at compile time, rather than building some kind of dispatch tree at runtime. After trying some more elaborate methods (e.g. building a decision tree via CPS), I figured out that just indexing (on the first field, by default) and then doing linear search within the index's patterns got 90% of the benefit with very little runtime analysis.

I haven't found libraries lacking, but we probably work on different things, and I don't have any problem with writing quick wrappers for existing C libraries. There's a fair bit of Lua libs that are insufficiently documented or tested, or have bit-rot (esp. due to changes in Lua itself), but the situation is getting better. For libs, I usually check http://lua-users.org/wiki/LibrariesAndBindings and http://luarocks.org/repositories/rocks/ . I've written a couple libraries, as well. See e.g. lunatest (http://github.com/silentbicycle/lunatest, an xUnit-like + randomized (QuickCheck-ish) testing library) and Tamale (http://github.com/silentbicycle/tamale, Erlang-style pattern-matching for Lua).

Lua is, IMHO, "Javascript done right". It's nice to have the option of writing C code but letting Lua do garbage-collection on common userdata. Lua replaced Python for me - it's a great language on its own. TCO and pattern matching (http://github.com/silentbicycle/tamale) go a long way.

Each table (dict, hash, whatchamacallit) has a hash portion and an array portion, and contiguous integer keys are stored internally in the array. So, tables automatically adapt their internal implementation for use as an array, a dict, or both, at runtime. They're unique to Lua, AFAIK. It also has an interesting hash table optimization (that I don't quite grok). I've been reading through the Lua code bit by bit, but haven't made it there yet. Lots of other interesting stuff, though. LuaJIT's not too shabby, either! Lua's my favorite language for quick hacks, period. I wrote a library to add fairly idiomatic pattern matching (http://github.com/silentbicycle/tamale/). Every language needs pattern matching. :) I'm still working on explaining PM to people who aren't already into Erlang or ML, but it's documented now.

Yes, and thanks. :) Have you seen my library (http://github.com/silentbicycle/tamale) for doing Erlang-style pattern matching in Lua, BTW? I still need to document it (I'm working on briefly explaining why pattern matching matters to people who have never used it), but in the mean time, a glance at the README and the test suite should suffice.

Well, there are plenty at LuaRocks (http://luarocks.org/repositories/rocks/). It's no CPAN, but the essentials are there. I'm working on a couple, such as Tamale (http://github.com/silentbicycle/tamale/), which adds Erlang-style pattern matching. I'll post it on LuaRocks once the docs are done. Of course, if you're embedding Lua (in a game, for example) you've already got the libraries you need, and extra libraries would just get in the way.

The major benefit with awk is that it runs as a pattern recognizing/processing filter by default, so it handles certain common problems in very little code, and fits particularly well in Unix shell pipelines. I'm also a big fan of structuring code in terms of pattern-matching. (I wrote an Erlang-style pattern matching library for Lua, btw: http://github.com/silentbicycle/tamale/ ) I write a lot of little awk scripts, but if they grow past ~5 lines, they usually get rewritten in Lua. (Perhaps eventually with inner loops in C.) Still, Awk is simple and useful enough that it's still worth knowing.

Same here. Unification rocks, though I think to have full unification rather than just pattern matching, the language needs logic variables first. (Right?) "Just" pattern matching is still great, though. FWIW, I'm working on a pattern-matching library for Lua. (tamale: http://github.com/silentbicycle/tamale) It uses linear search and backtracking rather than compiled decision trees at the moment, though I have the latter mostly done - there are a few failing tests for variable corner cases, though. (Maybe I'll get to them this weekend.) It allows repeating variables in patterns, too.