Explorando Groovy, Parte I

Tenía tiempo que no sentía emoción por aprender un lenguaje de programación nuevo, y conste que tengo la costumbre de asomarme a lenguajes de programación nuevos cada cierto tiempo, pero como los lenguajes que domino bien (c, c++ y java) junto a los que conozco lo suficiente como para desarrollar en serio con ellos (bash, c#, javascript y php) cubren en general mis necesidades profesionales, no me he quedado vinculado a ninguno nuevo producto de mis múltiples exploraciones: perl, python, ruby, sather, ocalm, lisp, prolog, basic, pascal, D, y pare de contar.

Pero en estos días en un violento ataque de amor/odio sadomasoquista típico de mi relación con java decidí explorar que otras alternativas existen para desarrollar sobre la JVM, de todos los lenguajes diferentes a java que están proliferando en ese entorno dos aparentan tener un crecimiento realmente importante desde el punto de vista de las comunidades que alrededor de ellos se están formando: Scala y Groovy. Y luego de invertir unas 4 horas con estos dos muchachos el Groovy hizo click en mi cerebro y por lo tanto decidí profundizar mi entendimiento de este señor.

No voy a ponerme a describir el lenguaje, ni su historia, para eso esta wikipedia y otras muchas fuentes que hablan del groovy, lo que si voy es a ir describiendo en varios artículos algunas de las cosas que me han hecho tan atractivo el lenguaje, creo que lo mas importante para mi es que groovy me hace sentir el poder de programar en un lenguaje rico y expresivo como python o ruby, pero con una sintaxis mucho mas familiar y cómoda (para mi cerebro de c++)

Ya pasando a tema mas concreto y mostrar algunas de las cosas de groovy les dejo el siguiente código que hice para probar algunos conceptos sobre listas, mapas y closures:

// ClosuresTest1.groovy
/* Esta clase la vamos a emplear para validar datos con respecto a un valor
 * limite máximo con el cual la iniciamos en su construcción.
 */
class MaxLimit { 
    int limit 
    MaxLimit(int limit) {
        this.limit = limit
    } 
    boolean validate(String value) {  
        value.length() <= limit
    } 
    boolean validate(int value) {
        value <= limit
    } 
    String message(String value) {
        "String  limit $limit, length ${value.length()}, value $value"
    } 
    String message(int value) {
        "int limit $limit, value $value"
    }
}
// creamos una lista con tres objetos de MaxLimit con limites 4, 5 y 5
def limits = [ new MaxLimit(4), new MaxLimit(6), new MaxLimit(5) ]

/* creamos una lista de closures, aquí se puede ver ya algunas de las 
 * idiosincrasias de groovy:
 * 1.- con .each recorremos la lista 'limits' donde la variable automática 'it' 
 *     toma el valor de cada objeto iterado
 * 2.- con .add agregamos elementos a la lista 'closures'
 * 3.- lo que agregamos a la lista 'closures' son mapas con dos llaves: 
 *     validate y message cada una apuntando por referencia a los métodos del 
 *     mismo nombre del objeto 'it' iterado. Aquí mostramos lo poderoso que es
 *     la capacidad de manejo de multimetodos donde podemos apuntar con un solo 
 *     closure a varios métodos con el mismo nombre pero con diferentes  
 *     argumentos, definitivamente muy poderoso y elegante.
 */
def closures = []
limits.each { closures.add([validate: it.&validate, message: it.&message]) }

def data = [6, 'long string', 'medium', 'short', 'tiny', 5, 4]

/* Aquí recorremos una lista heterogénea de datos 'data' e internamente  
 * recorremos y aplicamos la lista 'closures' a cada 'datum', imprimiendo
 * el mensaje del objeto MaxLimit en caso que validate sea verdadero.
 * Imaginen toda la basura sintactica que llevaria hacer lo mismo con java.
 */
data.each { datum ->
    closures.each { closure -> 
     if (closure.validate(datum)) println closure.message(datum) 
    } 
}