Scala es un lenguaje de programación multi-paradigma que combina programación orientada a objetos y funcional, diseñado para ser escalable y ejecutarse en la JVM. Su sintaxis concisa y características avanzadas lo hacen popular para el desarrollo de aplicaciones distribuidas, especialmente con frameworks como Apache Spark.

Configuración del entorno de desarrollo

Para comenzar con Scala, es necesario tener instalado Java Development Kit (JDK). Descargue el instalador de Scala desde el sitio oficial y descomprímalo en una carpeta dedicada. Configure las variables de entorno SCALA_HOME y agregue el directorio bin al PATH. Verifique la instalación ejecutando scala en la terminal.

Conceptos básicos de Scala

Variables y tipos de datos

En Scala, las variables se declaran con val (inmutable) o var (mutable). Los tipos de datos incluyen primitivos como Int, Double, Boolean, y tipos de colecciones. La inferencia de tipos permite omitir la anotación explícita.

// Ejemplo de variables con diferentes tipos
val immutableVar: Int = 42
var mutableVar = "texto"
mutableVar = "nuevo valor"

Estructuras de control

Los bucles for y while funcionan de manera similar a otros lenguajes, pero con sintaxis particular. Las expresiones if-else retornan valores, lo que permite asignarlas a variables.

// Bucle for con range
for (i <- 1 to 5) {
  println(s"Iteración: $i")
}

// Expresión if-else como valor
val resultado = if (mutableVar.length > 10) "largo" else "corto"

Colecciones en Scala

Scala ofrece colecciones inmutables por defecto, como List, Set y Map. Las colecciones mutables se encuentran en el paquete scala.collection.mutable. Las operaciones funcionales como map, filter y reduce son fundamentales.

// Uso de List y operaciones funcionales
val numeros = List(1, 2, 3, 4, 5)
val pares = numeros.filter(_ % 2 == 0)
val cuadrados = numeros.map(n => n * n)

// Map con pares clave-valor
val edades = Map("Ana" -> 25, "Luis" -> 30)

Programación orientada a objetos

Las clases se definen con class y pueden incluir contsructores primarios y auxiliares. Los objetos singleton se crean con object. Los traits actúan como interfaces con implementación parcial, permitiendo herencia múltiple.

// Clase con constructor primario
class Persona(val nombre: String, edad: Int) {
  def saludar(): String = s"Hola, soy $nombre"
}

// Trait con método abstracto
trait Identificable {
  def id: String
}

// Implementación de trait
class Usuario(val nombre: String) extends Identificable {
  def id = nombre.hashCode.toString
}

Programación funcional

Las funciones son ciudadanos de primera clase en Scala. Las funciones de orden superior aceptan funciones como parámetros o retornan funciones. Los literales de función (fucniones anónimas) se definen con la sintaxis (parámetros) => cuerpo.

// Función de orden superior
def aplicarOperacion(a: Int, b: Int, operacion: (Int, Int) => Int): Int = {
  operacion(a, b)
}

val suma = (x: Int, y: Int) => x + y
val resultado = aplicarOperacion(3, 4, suma)

// Uso de métodos funcionales en colecciones
val palabras = Array("hola", "mundo", "scala")
val longitudes = palabras.map(_.length)

Características avanzadas

El pattern matching con match-case permite desestructurar datos y manejar casos específicos. Las case class simplifican la definición de clases con métodos automáticos. La conversión implícita permite añadir funcionalidades a clases existentes sin modificar su código.

// Pattern matching con case class
case class Punto(x: Int, y: Int)

def describirPunto(punto: Punto): String = punto match {
  case Punto(0, 0) => "Origen"
  case Punto(x, 0) => s"Eje x en $x"
  case Punto(0, y) => s"Eje y en $y"
  case _ => "Punto general"
}

Para practicar, modifique ejemplos existentes o implemente algoritmos simples usando las características de Scala. La integración con herramientas como IntelliJ IDEA facilita el desarrollo y la depuración.