Generalización de las expresiones For¶

Las expresiones for en Scala se pueden utilizar para realizar consultas sobre colecciones de objetos de manera declarativa y concisa. Estas expresiones permiten combinar operaciones de filtrado, mapeo y anidamiento de colecciones de forma legible.

Ejemplos prácticos¶

Definición de datos¶

// Definición de una clase de caso para representar personas
scala> case class Persona(nombre:String, edad:Int)
class Persona

// Creación de instancias de Persona
scala> val p1 = Persona("Juan", 20)
val p1: Persona = Persona(Juan,20)

scala> val p2 = Persona("Maria",30)
val p2: Persona = Persona(Maria,30)

scala> val p3 = Persona("Juanito",15)
val p3: Persona = Persona(Juanito,15)

// Creación de una colección Vector con las personas
scala> val personas = Vector(p1,p2,p3)
val personas: scala.collection.immutable.Vector[Persona] = Vector(Persona(Juan,20), Persona(Maria,30), Persona(Juanito,15))

Consulta simple con filtro¶

// Expresión for para filtrar personas menores o iguales a 25 años y extraer sus nombres
scala> for{
     | p <- personas           // Iterar sobre cada persona en la colección
     | if p.edad <= 25         // Filtrar solo personas con edad <= 25
     | } yield p.nombre        // Extraer el nombre de cada persona filtrada
val res10: scala.collection.immutable.Vector[String] = Vector(Juan, Juanito)

Consulta compleja con múltiples generadores¶

// Expresión for para encontrar pares de personas distintas cuya suma de edades sea menor a 50
scala> (for{
     | p1 <- personas          // Primer generador: iterar sobre todas las personas
     | p2 <- personas          // Segundo generador: iterar nuevamente sobre todas las personas
     | if p1 != p2             // Filtrar pares donde las personas sean diferentes
     | if p1.edad + p2.edad < 50  // Filtrar pares cuya suma de edades sea menor a 50
     | } yield (p1.nombre,p2.nombre)).distinct  // Extraer nombres y eliminar duplicados
val res14: scala.collection.immutable.Vector[(String, String)] = Vector((Juan,Juanito), (Maria,Juanito), (Juanito,Juan), (Juanito,Maria))

Fundamentos teóricos¶

Las expresiones for en Scala son azúcar sintáctico (syntactic sugar) para las operaciones map, flatMap y withFilter. Esto significa que el compilador traduce las expresiones for a llamadas a estos métodos, lo que permite una sintaxis más legible sin perder la potencia funcional.

Diferencias entre `filter` y `withFilter`¶

// filter: evalúa el predicado sobre toda la colección y devuelve una nueva colección
scala> (1 to 10).filter(_ > 2)
val res22: IndexedSeq[Int] = Vector(3, 4, 5, 6, 7, 8, 9, 10)

// withFilter: crea una vista perezosa (lazy) que filtra a medida que se procesan los elementos
scala> (1 to 10).withFilter(_ > 2)
val res23: scala.collection.WithFilter[Int,[_]IndexedSeq[_]] = scala.collection.IterableOps$WithFilter@50f8d4f3

// Uso de withFilter dentro de una expresión for
scala> for{
     | i <- (1 to 10).withFilter(_ > 2)  // Filtrado perezoso
     | } yield i

Ventaja de withFilter: Puede filtrar elementos a medida que se generan, lo que es más eficiente en términos de memoria cuando se trabaja con colecciones grandes o secuencias infinitas. En contraste, filter necesita evaluar toda la colección antes de proceder.

Compatibilidad con colecciones¶

La expresión for trabaja sobre cualquier tipo que implemente los métodos map, flatMap y withFilter. Esto incluye las principales colecciones de Scala como List, Vector, Array, Seq, Set, Map, entre otras. Esta generalidad permite usar la misma sintaxis for con diferentes estructuras de datos.

Tabla de resumen¶

Concepto	Descripción	Ejemplo/Notas
Expresión `for`	Constructo para iterar y transformar colecciones de manera declarativa	`for (x <- coleccion) yield transformacion(x)`
Azúcar sintáctico	Las expresiones `for` se traducen a llamadas a `map`, `flatMap` y `withFilter`	Mejora la legibilidad del código
`withFilter`	Método para filtrado perezoso (lazy) que procesa elementos según se necesitan	Más eficiente en memoria que `filter` para colecciones grandes
`filter`	Método para filtrado estricto que evalúa toda la colección antes de continuar	Devuelve una nueva colección con los elementos filtrados
Múltiples generadores	Permite anidar iteraciones sobre diferentes colecciones	Útil para combinaciones y productos cartesianos
Guardas (`if`)	Condiciones para filtrar elementos durante la iteración	Se pueden incluir múltiples condiciones en una expresión `for`
`yield`	Palabra clave para producir resultados de la expresión `for`	Sin `yield`, la expresión es un bucle `for` tradicional (con efectos secundarios)
Compatibilidad	Funciona con cualquier tipo que implemente `map`, `flatMap` y `withFilter`	`List`, `Vector`, `Array`, `Set`, `Map`, `Option`, `Future`, etc.

Comentarios adicionales¶

Eficiencia: Las expresiones for con múltiples generadores pueden generar productos cartesianos grandes. Es importante considerar la complejidad algorítmica cuando se trabaja con colecciones extensas.
Legibilidad vs. rendimiento: Aunque las expresiones for son más legibles, en algunos casos de alto rendimiento puede ser preferible usar directamente map, flatMap y filter para tener mayor control sobre las optimizaciones.
Monadas: El mecanismo subyacente de las expresiones for está basado en el concepto de mónadas de la programación funcional, lo que explica su compatibilidad con tipos diversos como Option, Try, Future y colecciones. Una mónada es un patrón de diseño en programación funcional que permite estructurar programas de manera que manejen efectos secundarios, secuenciación de operaciones y contextos computacionales de forma controlada y composicional.
Traducción por el compilador: El compilador de Scala traduce las expresiones for a una secuencia de llamadas a métodos. Por ejemplo, for (x <- c; if cond) yield f(x) se traduce a c.withFilter(cond).map(f).
Uso con Option y Future: Las expresiones for son particularmente útiles para trabajar con tipos monádicos como Option y Future, permitiendo manejar secuencias de operaciones que pueden fallar de manera elegante.