Scala: Parte 2

Los primeros pasos en Scala
Como había comentado en mi post anterior sobre el lenguaje Scala, mi pretensión es contribuir "paso a paso" con algunas de las cosas importantes de este lenguaje, discutiendo conceptos relevantes y algo de código para ilustrar esos conceptos.
Creo que es necesario aprender a caminar con pasos firmes para después correr, y por esa razón me voy despacio explicando cada cosa en su momento.
Casi todos los libros y tutoriales de Scala aconsejan comenzar con el intérprete de Scala y "oyendo" a los que saben voy a hacer lo mismo, aunque también me gustaría "saltar del REPL a programas completos. Esa forma me ha ayudado a entender el lenguaje, aunque debo confesar que aun me falta mucho por aprender y que bueno que sea así pues evito el aburrimiento.
El REPL (Read Eval Print Loop) es un shell interactivo que compila código de Scala y retorna el resultado (o el tipo) de manera inmediata. Espero que todos los que leen esto ya tengan en su máquina a Scala y puedan interactuar con el intérprete a medida que leen esta notas.
Definamos algunas variables en el REPL:
 
El intérprete me responde:
 
EL REPL es muy verboso y me indica que definí una variable y el tipo usado. "Hola Java Mexico" es un literal String y notamos que Scala utiliza la clase   para los tipos cadena de caracteres.
Esa línea simple ilustra algunos conceptos simples pero importantes del lenguaje entre ellos los siguientes:
La sintaxis de Scala es más regular que la sintaxis de Java en el sentido que todas las definiciones comienzan con una palabra reservada. Las variables se definen con   y   y las funciones se definen con  . El uso de   también lo encontraremos prefijando a los parámetros de funciones cuando deseamos utilizar "call by name". Eso lo veremos en otro momento.
Scala es un lenguaje de tipado estático con inferencia de tipos. El código
 
no especifica el tipo de mensaje, porque el lenguaje puede inferirlo del tipo de resultado de la expresión de la parte derecha de la asignación. Podríamos por supuesto ser muy explícitos y escribir:
 
y el REPL me devuelve
 
Observen que ahora el REPL especifica el tipo con su nombre parcial: no usa el nombre totalmente calificado de la clase  .
El REPL acepta una nueva redefinición de la variable porque comienza un nuevo ámbito (scope). En un programa normal esa nueva línea resultaría en un error de compilación.
Escribimos ahora:
 
y el REPL nos dice:
 
Scala tiene dos tipos de variables, vals y vars. Una variable definida con val asocia un identificador con un valor inmutable. En ocasiones se dice que la variable definida así es inmutable. Si se desea pensar en términos de la programación funcional, es mejor decir que es el valor quien es inmutable y por tanto el identificador que usamos para referirnos a él no puede ser cambiado. No es un pecado decir que un val es similar a una variable final en Java.
Una variable definida con var es una variable en realidad y el valor que identifica puede cambiar durante la ejecución del programa. El código siguiente es válido:
 
Podemos aplicar métodos de la clase   sobre un literal cadena, de la misma forma que hacemos en Java:
 
O haciendo uso de la sintaxis de "operadores" infijos que Scala brinda:
 

Conversiones implícitas
¿Qué tal el código siguiente?
 
El método   no está definido para la clase  , por lo que algo más está interviniendo aquí, para que lo anterior no produzca un error de compilación.
Ese algo más son las conversiones implícitas en Scala: una de las soluciones que este lenguaje ofrece para "extender" la funcionalidad de una clase que no nos pertenece y que no tenemos la opción de extenderla por las vías "normales" de la herencia y la composición.
Como todos conocen, hay una diferencia fundamental entre nuestro código (clases y otras cosas que diseñamos) y el código que usamos de bibliotecas y otros diseñadores. Con nuestro código podemos hacer lo que queramos, mientras con el código de terceros no nos queda otra que usarlo tal cual.
En ocasiones necesitamos extender ese código de terceros. Varios lenguajes brindan varias técnicas para eso. Ruby ofrece el mecanismo de módulos, C# ofrece los métodos de extensión estáticos, etc.
Scala por su parte introduce la técnica de parámetros y conversiones implícitas, con las cuales se le brinda información adicional al compilador para poder usar esas conversiones ante la presencia de errores de compilación debidos fundamentalmente a compatibilidad entre tipos.
¿Qué hace el compilador cuando encuentra la línea:
 
Pues lo primero que hace es percatarse de que hay un error de compilación. El método   no es un método de la clase  . Inmediatamente que esto sucede, el compilador trata de buscar alguna función de conversión implícita que solucione este problema y que por supuesto esté en ámbito (scope). Esa función tendrá que lograr "convertir" el literal String, en un objeto de alguna clase que tenga el método   y que produzca un nuevo objeto de tipo   con el resultado esperado.
En el ámbito de todo programa en Scala se dispone de un objeto (¿un objeto o una clase?) denominado objeto Predef:
 
que dispone del método de conversión implícita siguiente:
 
El compilador se encarga también de "investigar" la clase  , y comprueba que esa clase ofrece el método   que invierte una "cadena". El compilador aplica "transparentemente" la conversión de  , invoca el método   sobre el objeto de tipo   y nos da como resultado la cadena invertida de tipo  .
El código del objeto incluye otras muchas definiciones utilitarias que tienen como objetivo escribir códigos más compactos. Por ejemplo escribimos:
 
¿Cómo está definida println?
Está definida en el objeto Predef así como otras funciones de impresión y lectura comunes como:
 

Definamos algunas funciones
La definición de una función en Scala comienza con la palabra reservada def, seguida por el nombre de la función, la lista o listas de parámetros (¿más de una lista?), el tipo de resultado, el signo igual y el bloque que define la función. Un ejemplo viene a continuación:
 

Usamos esa función:
 
Scala no puede inferir los tipos de sus parámetros, por lo que es obligada la anotación de tipos de los parámetros.
Las funciones en Scala no requieren en la mayoría de los casos la sentencia  . El resultado devuelto es el valor de la última expresión.
Scala utiliza el signo igual para enfatizar el concepto de función: el cuerpo de la función calcula algo y devuelve un resultado. Cuando se omite el signo igual nos referimos a un procedimiento destinado mayormente a producir efectos laterales o a realizar operaciones de I/O.
Scala puede inferir el tipo de resultado de una función: en este caso puede no escribirse el tipo de resultado de la función  . Puede inferirse del código.
Por ejemplo, ¿cuál es el tipo de retorno de la función siguiente?:
 
Si el argumento es verdadero, el tipo de retorno es   (se infiere del literal entero 5). Si el argumento es falso el tipo de retorno es   (se infiere del literal cadena "5").
El tipo de retorno entonces debe ser un tipo que sea base de los tipos valores y de los tipos referencias: el tipo Any.
 
Los dos ejemplos anteriores tienen cosas interesantes con respecto a la distinción entre expresiones y sentencias (statements). Noten que para el caso de la sentencia (statement)while tuvimos la necesidad de crear una variable temporal mutable para devolver el resultado, mientras que la estructura de control   es una expresión y se evalúa a un valor, sin la necesidad de hacer uso de variables mutables temporales.
La programación funcional tiene entre sus objetivos evitar los efectos laterales, la modificación del estado y hacer uso "exclusivamente" de expresiones que regresan un valor en el momento de ejecutarse. Que   es una expresión lo podemos demostrar en el REPL:
 
¿Por qué el siguiente código no compila?
 

Hoy es domingo y toca. Nos vemos en la próxima