{"id":178,"date":"2023-05-27T06:18:29","date_gmt":"2023-05-27T06:18:29","guid":{"rendered":"https:\/\/canessaalvamiguel.dev\/?p=178"},"modified":"2023-05-27T06:18:30","modified_gmt":"2023-05-27T06:18:30","slug":"for-comprehension-in-scala","status":"publish","type":"post","link":"https:\/\/canessaalvamiguel.dev\/index.php\/2023\/05\/27\/for-comprehension-in-scala\/","title":{"rendered":"For-Comprehension in Scala"},"content":{"rendered":"\n

En el mundo de la programaci\u00f3n funcional, Scala ofrece una caracter\u00edstica poderosa llamada for-comprehension<\/code> que nos permite manipular y transformar colecciones de una manera m\u00e1s legible y concisa. Esta caracter\u00edstica nos permiten expresar operaciones complejas en colecciones utilizando una sintaxis familiar similar a un bucle for<\/code>, pero con una sem\u00e1ntica funcional m\u00e1s poderosa. En este art\u00edculo, exploraremos esta caracter\u00edstica y c\u00f3mo utilizarla para simplificar el procesamiento de colecciones.<\/p>\n\n\n\n

\u00bfQu\u00e9 son las For-Comprehension?<\/h2>\n\n\n\n

Son una forma declarativa de expresar operaciones en colecciones. A diferencia de un bucle for<\/code> imperativo tradicional, las For-Comprehension<\/code> en Scala no modifican el estado mutable, sino que crean nuevas colecciones a trav\u00e9s de transformaciones y filtros. Esto hace que el c\u00f3digo sea m\u00e1s legible, mantenible y f\u00e1cil de razonar.<\/p>\n\n\n\n

Sintaxis b\u00e1sica:<\/h2>\n\n\n
\nfor (variable <- secuencia) expresi\u00f3n\n<\/pre><\/div>\n\n\n
La variable representa cada elemento de la secuencia en cada iteraci\u00f3n, y la expresi\u00f3n define la transformaci\u00f3n o filtro a aplicar al elemento. La For-Comprehension<\/code> devuelve una nueva colecci\u00f3n que contiene los resultados de las transformaciones o filtrados.<\/p>\n\n\n\n
Equivalencias<\/h2>\n\n\n\n
Es bueno tener en cuenta que las For-Comprehension<\/code> tambien se pueden entender como la combinacion de otras operaciones, es decir el siguiente codigo:<\/p>\n\n\n
\n    ('a' to 'c').flatMap { c =>\n      (0 to 2).map { n =>\n        c -> n\n      }\n    }\n<\/pre><\/div>\n\n\n
es equivalente al siguiente:<\/p>\n\n\n
\n    (for (c <- 'a' to 'c')\n      yield for (n <- 0 to 2)\n        yield c -> n).flatten\n<\/pre><\/div>\n\n\n
y tambien al siguiente:<\/p>\n\n\n
\n    for (c <- 'a' to 'c'; n <- 0 to 2)\n      yield c -> n\n<\/pre><\/div>\n\n\n
de la misma manera al siguiente:<\/p>\n\n\n
\n    for {\n      c <- 'a' to 'c'\n      n <- 0 to 2\n    } yield c -> n\n<\/pre><\/div>\n\n\n
todos estos hacen lo mismo y de la misma manera.<\/p>\n\n\n\n
Ejemplos<\/h2>\n\n\n\n
Filtrado de elementos:<\/strong>
Supongamos que tenemos una lista de n\u00fameros y queremos filtrar solo los n\u00fameros pares. Podemos usar una For-Comprehension<\/code> de la siguiente manera:<\/p>\n\n\n
\nval numbers = List(1, 2, 3, 4, 5, 6)\nval evenNumbers = for (num <- numbers if num % 2 == 0) yield num\n<\/pre><\/div>\n\n\n
En este ejemplo, la For-Comprehension<\/code> filtra los n\u00fameros pares utilizando la cl\u00e1usula if num % 2 == 0<\/code> y crea una nueva lista evenNumbers<\/code> que contiene solo los n\u00fameros pares.<\/p>\n\n\n\n
El valor de la variable evenNumber<\/code> seria:<\/p>\n\n\n
\nval evenNumbers: List[Int] = List(2, 4, 6)\n<\/pre><\/div>\n\n\n
Transformaci\u00f3n de elementos:<\/strong><\/p>\n\n\n\n
Supongamos que tenemos una lista de nombres y queremos crear una nueva lista que contenga la longitud de cada nombre. Podemos usar una For-Comprehension<\/code> de la siguiente manera:<\/p>\n\n\n
\nval names = List("Alice", "Bob", "Charlie")\nval nameLengths = for (name <- names) yield name.length\n<\/pre><\/div>\n\n\n
En este ejemplo, la For-Comprehension<\/code> recorre la lista de nombres y aplica la transformaci\u00f3n name.length<\/code> a cada nombre, creando una nueva lista nameLengths<\/code> que contiene las longitudes de los nombres.<\/p>\n\n\n\n
El valor de la variable nameLengths<\/code> seria:<\/p>\n\n\n
\nval nameLengths: List[Int] = List(5, 3, 7)\n<\/pre><\/div>\n\n\n
Combinaci\u00f3n de colecciones:<\/strong><\/p>\n\n\n\n
Podemos combinar varias colecciones utilizando m\u00faltiples cl\u00e1usulas for<\/code>. Supongamos que tenemos dos listas, una de nombres y otra de edades, y queremos crear una nueva lista que contenga las combinaciones de nombres y edades. Podemos hacerlo de la siguiente manera:<\/p>\n\n\n
\nval names = List("Alice", "Bob", "Charlie")\nval ages = List(25, 30, 35)\nval nameAgeCombinations = for {\n  name <- names\n  age <- ages\n} yield (name, age)\n<\/pre><\/div>\n\n\n
En este ejemplo, la For-Comprehension<\/code> combina cada nombre con cada edad, creando una nueva lista de tuplas (name, age)<\/code>.<\/p>\n\n\n\n
El valor de la variable nameAgeCombinations<\/code> seria:<\/p>\n\n\n
\nval nameAgeCombinations: List[(String, Int)] = List((Alice,25), (Alice,30), (Alice,35), (Bob,25), (Bob,30), (Bob,35), (Charlie,25), (Charlie,30), (Charlie,35))\n<\/pre><\/div>\n\n\n
Filtrado de opciones:<\/strong><\/p>\n\n\n\n
Supongamos que tenemos una lista de opciones y queremos filtrar solo las opciones que contienen un valor. Podemos utilizar una For-Comprehension<\/code> de la siguiente manera:<\/p>\n\n\n
\nval options = List(Some(1), None, Some(3), None, Some(5))\nval filteredOptions = for (option <- options if option.isDefined) yield option.get\n<\/pre><\/div>\n\n\n
En este ejemplo, la For-Comprehension<\/code> filtra las opciones que est\u00e1n definidas (isDefined<\/code>) y crea una nueva lista filteredOptions<\/code> que contiene solo los valores de las opciones definidas utilizando get<\/code>.<\/p>\n\n\n\n
El valor de la variable filteredOptions<\/code> seria:<\/p>\n\n\n
\nval filteredOptions: List[Int] = List(1, 3, 5)\n<\/pre><\/div>\n\n\n
Transformaci\u00f3n de opciones:<\/strong><\/p>\n\n\n\n
Supongamos que tenemos una lista de opciones de n\u00fameros y queremos crear una nueva lista que contenga los cuadrados de los n\u00fameros si est\u00e1n presentes. Podemos utilizar una For-Comprehension<\/code> de la siguiente manera:<\/p>\n\n\n
\nval numberOptions = List(Some(1), None, Some(3), None, Some(5))\nval squaredNumbers = for {\n  option <- numberOptions\n  number <- option\n} yield number * number\n<\/pre><\/div>\n\n\n
En este ejemplo, la For-Comprehension<\/code> recorre la lista de opciones y, si la opci\u00f3n est\u00e1 definida, extrae el valor number<\/code> y aplica la transformaci\u00f3n number * number<\/code> para crear una nueva lista squaredNumbers<\/code> que contiene los cuadrados de los n\u00fameros presentes en las opciones.<\/p>\n\n\n\n
El valor de la variable squaredNumbers<\/code> seria:<\/p>\n\n\n
\nval squaredNumbers: List[Int] = List(1, 9, 25)\n<\/pre><\/div>\n\n\n
Combinaci\u00f3n de opciones:<\/strong><\/p>\n\n\n\n
Podemos combinar m\u00faltiples opciones utilizando varias cl\u00e1usulas for<\/code>. Supongamos que tenemos dos opciones, una para el nombre y otra para la edad, y queremos crear una nueva opci\u00f3n que contenga la combinaci\u00f3n del nombre y la edad solo si ambos est\u00e1n presentes. Podemos hacerlo de la siguiente manera:<\/p>\n\n\n
\nval nameOption = Some("Alice")\nval ageOption = Some(25)\nval combinedOption = for {\n  name <- nameOption\n  age <- ageOption\n} yield s"$name is $age years old"\n<\/pre><\/div>\n\n\n
En este ejemplo, la For-Comprehension<\/code> combina la opci\u00f3n del nombre y la opci\u00f3n de la edad y, si ambas est\u00e1n presentes, crea una nueva opci\u00f3n combinedOption<\/code> que contiene la combinaci\u00f3n del nombre y la edad.<\/p>\n\n\n\n
El valor de la variable combinedOption<\/code> seria:<\/p>\n\n\n
\nval combinedOption: Option[String] = Some(Alice is 25 years old)\n<\/pre><\/div>","protected":false},"excerpt":{"rendered":"
En el mundo de la programaci\u00f3n funcional, Scala ofrece una caracter\u00edstica poderosa llamada for-comprehension que nos permite manipular<\/p>\n","protected":false},"author":1,"featured_media":62,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[36,8],"class_list":["post-178","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scala","tag-for-comprehension","tag-scala"],"_links":{"self":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/178","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/comments?post=178"}],"version-history":[{"count":16,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/178\/revisions"}],"predecessor-version":[{"id":194,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/178\/revisions\/194"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/media\/62"}],"wp:attachment":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/media?parent=178"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/categories?post=178"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/tags?post=178"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}