Choosing a dynamic language to learn (Ruby/Groovy/Scala)

I've had Ruby sitting in my ToDo list for far too long. I mean, at least for a couple of years! It's been so long that in the time some fellows have made into the list as well, namely Groovy and Scala.

Finally, this year, I've decided that the time has come and that I have to invest some effort. Unfortunately, I know have to decide where.

I will start saying that all three candidates share the basic functionality that I'm looking for:

• Scripting
  I want an interpreted language that saves me time to come up with quick prototypes and hacks. I want a powerful OS tool beyond shell scripts. I may need to compile to bytecode later as well.
• Elegance and expressiveness
  I want to avoid boilerplate. I need dynamic typing and runtime inference. I want syntax sugar! I want easy to read DSLs.
• Closures
  They are a must. My only concern is readability but beyond that I cannot understand why Java does not have them yet.
• Mixins
  Inheritance on steroids.
• Go Functional
  Try to combine imperative style with some characteristics natural to functional programming. Less what and more how (descriptive style).

In the end, I want to be productive and those are the minimal requirements (nowadays). Beyond that, it's a matter of taste. Here's a little list of pros and cons of each. Take it with a grain of salt, this list is based on my personal preferences, many points will not be worth something to anyone but me:

• Ruby
  The first of the crop and the most popular for sure.
  • Pros
    • Refreshing (depart from C syntax)
    • Rails
    • Mature (since 1995)
    • Community
    • JRuby / SUN involvement (leverage the Java platform)
  • Cons
    • Too much hype
    • Lacks "enterprise" consideration (Threading? Scaling?)
    • Low ROI (see market penetration)
    • Is it loosing momentum?
• Groovy
  Enterprise capabilities along with cool productivity features
  • Pros
    • Tight Java / JVM integration
    • Extends JDK API(GDK)
    • Easyness / Learning curve
    • Out-of-the-box Spring integration
    • Grails
  • Cons
    • Performance
• Scala
  A general purpose (multi-paradigm) programming language
  • Pros
    • Interoperability with Java
    • Language features not retrofitted (ie Genericity)
    • Actors, concurrency and distributed programming
    • Implicit enrichment of a Java class
    • Statically typed with inference
  • Cons
    • Tooling
    • Not mainstream yet
    • Smaller community

In the end, I've chosen Groovy. I'm a geek, true. But I'm also a lazy developer and I like to apply my knowledge on day-by-day basis. For me that's easier in the Java camp (ie. with Spring).

I could choose JRuby then, but I'm not sure that's the correct path even though Sun's commitment (for example, with Netbeans and the compiler) seems pretty heavy.

Scala could be. Indeed it's improving (as the others) but it's not there yet. In the end, Scala seems more like a (future) Java replacement and that's not what I'm looking for right now.