Scala - Parte 1: Introducción

Luego de mucho tiempo de no escribir una entrada nueva al blog, me comprometo a redactar una serie de entradas para introducirlos en este lenguaje que me tiene fascinado: Scala

Existen dos motivos que me llevó a tomar ésta desición: 1-No existen muchos artículos en castellano sobre el tema. 2-Lo escribo más para mi que para los lectores a modo de repaso de lo estudiado.

Bien, comencemos.

¿Por donde empezar?
Lo primero que debemos hacer es visitar el sitio oficial de Scala y bajarnos su última versión.

Mientras descargamos les cuento que Scala es un lenguaje multiparadigma que convina la Orientación a Objetos con la Programación Funcional. Si bien se lo puede catalogar como de tipado fuerte, permite la inferencia de tipos. Como lenguaje Orientado a Objetos es tan puro como lo es Smalltalk. Es decir, todo en Scala es un objeto, no existen los tipos nativos. Si escibimos un valor literal como podría ser un entero veremos que éste tiene métodos.
Scala compila a bytecode para la JVM. Aunque existe una versión para .NET. Los astutos ya se habrán imaginado que entonces es requisito tener instalado un JRE para ejecutar una aplicación Scala.
Además de ésto tenemos el potencial de poder reutilizar todas las Apis y librerias de Java importandolas en nuestro código Scala de manera muy sencilla. Importante es aclarar que el paquete java.lang esta implícitamente importado en el lenguaje.

Existen plugins tanto para los ide's Netbeans como para Eclipse con caracteristicas poderosas que van más allá del simple coloreado de sintaxis. Como si fuera poco la distribución de Scala nos trae una propia herramienta REPL que no es otra cosa que un iterprete Scala. Para invocarla y tirar nuestro primer "hola mundo" sólo hace falta ejecutar la orden scala desde el shell de nuestra terminal del S.O. Previamente y una vez descargada la distribución deberemos descomprimirla en algun directorio y establecer el directorio /bin de Scala para que sea accedido desde cualquier path. Para ésto desde Windows editamos la variable de entorno path agregando el directorio /bin de nuestra instalación Scala. Los linuxeros ya sabrán como hacerlo, ni me gasto :P

Hola Mundo Scala!
Para nuestro primer hola mundo accedemos al interprete de scala ejecutando scala.bat desde el directorio /bin de la instalación o simplemente ejecutando scala si tenemos configurado el path en la variable de entorno.

scala> println("Hola Mundo Scala!")
Hola Mundo Scala!

Declarando variables
Si declaramos las variables con la palabra reservada val, la variable puede ser asignada con un valor una sola vez, similar a cuando declaramos con el modificador final de Java.

scala> val msg = "Hola Mundo Scala!"
msg: java.lang.String = Hola Mundo Scala!
scala> println(msg)

Cuando queramos asignarle un nuevo valor el error producido es el siguiente:

scala> msg = "Hola de nuevo"
:5 error: assignment to non-variable
val unnamed4 = {msg = "Hola de nuevo";msg}

Por el contrario si declaramos la variable con la palabra reservada var, ésta podrá reasignarsele valores todas las veces que queramos.

scala> val msg2 = "Hola cambiante"
msg2: java.lang.String = Hola cambiante
scala> msg2 = "Hola de nuevo"
msg2: java.lang.String = Hola de nuevo
scala> println(msg2)
Hola de nuevo

Definiendo métodos
Ahora veamos algunas definiciones de métodos en Scala:

scala> def max(x: Int, y: Int): Int = if (x < y) y else x max: (Int,Int)Int 

Éste método calcula el máximo de los dos valores enteros argumentados. En la definición está indicado explícitamente el tipo de retorno del método. Algunas veces el compilador requiere que especifiquemos el tipo. Si el método es recursivo, por ejemplo, es necesario explicitar el tipo del resultado del método. Pero en el ejemplo anterior es posible obviar el tipo del retorno en la definición porque el compilador es capaz de darse cuenta por inferencia:

scala> def max2(x: Int, y: Int)= if (x < y) y else x max2: (Int,Int)Int

Podemos observar como Scala sabe por inferencia que el retorno es un objeto Int.

En los ejemplos anteriores el cuerpo del método está definido en una sola sentencia. Pero si el método fuera más complejo el cuerpo debería estar enmarcado dentro de un bloque. Al igual que Java y C, Scala usa las llaves { } para limitar los bloques de código:

scala> def max3(x: Int, y: Int) = { if (x < y) y else x } max3: (Int,Int)Int 

Podemos comprobar el resultado del método con:

scala> println(max(5,2))
5

Cuando el método no necesita argumentos es posible definirlo de la siguiente manera:

scala> def saludo = println("Hola, soy un metodo sin argumentos")
saludo: Unit

Además podemos notar que ahora el retorno del compilador indica que el método saludo no tiene parametros y que retorna un Unit. Un Unit viene a representar lo que es un void en Java. Para usarlo podemos escribir:

scala> saludo
Hola, soy un metodo sin argumentos

Bueno, por ahora dejo sólo esto pero espero volver con más en un par de días. Mientras vale seguir experimentando, sobre todo para los que vienen de Java. No sean flojos! :)