En Scala, al igual que en otros lenguajes de programación, existen diferentes tipos de datos que nos permiten manejar información de diversas formas. Entre ellos encontramos los enteros, los números de punto flotante, los booleanos, las cadenas de texto y muchos más. Sin embargo, hay un tipo especial que merece nuestra atención: el tipo Unit. Este tipo es el equivalente al void en lenguajes como Java o C++, y se utiliza para funciones que no devuelven ningún valor.
Las funciones que devuelven Unit simplemente ejecutan código sin retornar un resultado. Un caso muy común donde utilizamos este tipo es en la definición de la función main, que es el punto de entrada de cualquier programa en Scala. Esta función recibe un parámetro llamado args, que es un arreglo de cadenas (Array[String]), y su propósito es iniciar la ejecución del programa. Al igual que en Java, la función main en Scala no devuelve nada, por lo que su tipo de retorno es Unit.
Históricamente, en Scala existía una forma de definir funciones que devuelven Unit sin necesidad de poner un signo igual (=) después de los paréntesis de la definición. Por ejemplo, podríamos escribir una función main así:
def main(args: Array[String]) {
println("Hola mundo")
}
En este caso, al no poner el igual, Scala asume que la función devuelve Unit. Sin embargo, esta práctica ya no está recomendada. El motivo principal es que omitir el igual puede llevar a errores sutiles y difíciles de detectar, especialmente cuando queremos que una función devuelva un valor distinto de Unit.
Por ejemplo, imaginemos que definimos una función para sumar dos números enteros, pero olvidamos poner el igual:
def suma(a: Int, b: Int): Int {
a + b
}
Aunque la última línea es una expresión que devuelve la suma de a y b, al no poner el igual, Scala interpreta que la función devuelve Unit. Esto significa que, al llamar a suma(2, 3), no obtendremos el resultado esperado, sino que la función no devolverá nada útil. Este tipo de error puede pasar desapercibido si no prestamos atención, y es precisamente por eso que se recomienda siempre incluir el igual en la definición de funciones.
Si en cambio definimos correctamente la función con el igual, el compilador nos avisará si cometemos algún error:
def resta(a: Int, b: Int): Int = {
a - b
}
Si olvidamos el igual aquí, el IDE o el compilador nos marcarán un error, lo que facilita detectar y corregir el problema.
Por lo tanto, la forma recomendada de definir funciones que devuelven Unit, como la función main, es siempre incluir el igual explícitamente:
def main(args: Array[String]): Unit = {
println("Hola mundo")
}
De esta manera, evitamos confusiones y errores relacionados con el tipo de retorno de nuestras funciones.
En resumen, aunque en documentación antigua de Scala podamos encontrar funciones Unit definidas sin el igual, es mejor adoptar la práctica actual de incluirlo siempre. Esto nos ayuda a escribir código más claro y menos propenso a errores, especialmente cuando trabajamos con la inferencia de tipos que Scala ofrece. Así, garantizamos que nuestras funciones se comporten tal y como esperamos y mantenemos la calidad y legibilidad de nuestro código.