{"id":215,"date":"2023-06-15T00:14:00","date_gmt":"2023-06-15T00:14:00","guid":{"rendered":"https:\/\/canessaalvamiguel.dev\/?p=215"},"modified":"2023-06-15T00:19:10","modified_gmt":"2023-06-15T00:19:10","slug":"immutability-in-scala","status":"publish","type":"post","link":"https:\/\/canessaalvamiguel.dev\/index.php\/2023\/06\/15\/immutability-in-scala\/","title":{"rendered":"Immutability in Scala"},"content":{"rendered":"\n

En el desarrollo de software, la inmutabilidad es un concepto clave en el paradigma de programaci\u00f3n funcional y juega un papel fundamental en la construcci\u00f3n de c\u00f3digo robusto y confiable. En Scala la inmutabilidad se promueve como una pr\u00e1ctica recomendada. <\/p>\n\n\n\n

\u00bfQu\u00e9 es la inmutabilidad?<\/h2>\n\n\n\n

En programaci\u00f3n, la inmutabilidad se refiere a la propiedad de un objeto o valor que no puede cambiar despu\u00e9s de ser creado. En Scala, los objetos inmutables no pueden ser modificados una vez que se han creado, lo que implica que cualquier intento de cambiar su estado resultar\u00e1 en la creaci\u00f3n de una nueva instancia con los cambios deseados. Esta caracter\u00edstica contrasta con la mutabilidad, donde los objetos pueden cambiar su estado a lo largo del tiempo.<\/p>\n\n\n\n

Beneficios de la inmutabilidad:<\/h2>\n\n\n\n

La inmutabilidad ofrece una serie de beneficios significativos en el desarrollo de software:<\/p>\n\n\n\n

    \n
  1. Evita efectos secundarios inesperados:<\/strong> Al utilizar objetos inmutables, se evitan los efectos secundarios no deseados que pueden surgir cuando varios componentes comparten y modifican el mismo estado mutable. Esto mejora la predictibilidad y facilita el razonamiento sobre el comportamiento del programa.<\/li>\n\n\n\n
  2. Simplifica la concurrencia:<\/strong> Los objetos inmutables son intr\u00ednsecamente seguros para su uso en entornos concurrentes. Como no se pueden modificar, no hay problemas de concurrencia relacionados con el acceso simult\u00e1neo y la modificaci\u00f3n de estado. Esto facilita la creaci\u00f3n de programas concurrentes y ayuda a evitar errores comunes asociados con la concurrencia.<\/li>\n\n\n\n
  3. Facilita el razonamiento y el testing:<\/strong> Al utilizar objetos inmutables, el comportamiento de un objeto se puede razonar de manera aislada sin tener que considerar cambios en su estado. Esto hace que el c\u00f3digo sea m\u00e1s f\u00e1cil de entender, depurar y testear, ya que no se requiere realizar un seguimiento de cambios y mutaciones de estado en m\u00faltiples lugares.<\/li>\n\n\n\n
  4. Fomenta la reutilizaci\u00f3n de c\u00f3digo:<\/strong> Los objetos inmutables son m\u00e1s f\u00e1ciles de reutilizar en diferentes contextos y componentes, ya que su estado no cambia. Esto promueve la modularidad y el dise\u00f1o de componentes independientes y cohesivos.<\/li>\n<\/ol>\n\n\n\n

    Ejemplos de inmutabilidad en Scala:<\/h2>\n\n\n\n

    Case class inmutable:<\/strong><\/p>\n\n\n

    \ncase class Persona(nombre: String, edad: Int)\nval persona = Persona("Juan", 30)\nval personaActualizada = persona.copy(edad = 31)\n<\/pre><\/div>\n\n\n
    En este ejemplo, la case class Persona<\/code> es inmutable. Una vez que se crea una instancia de Persona<\/code>, sus campos no se pueden modificar. Para realizar cambios, se crea una nueva instancia utilizando el m\u00e9todo copy<\/code> que devuelve una nueva instancia de Persona<\/code> con los campos modificados.<\/p>\n\n\n\n
    Colecciones inmutables:<\/strong><\/p>\n\n\n
    \nval lista = List(1, 2, 3)\nval listaActualizada = lista :+ 4\n<\/pre><\/div>\n\n\n
    En este caso, la lista lista<\/code> es inmutable. No se pueden agregar ni eliminar elementos de la lista existente. En cambio, se crea una nueva lista listaActualizada<\/code> utilizando el operador :+<\/code> que agrega un elemento al final de la lista original.<\/p>\n\n\n\n
    Valores inmutables:<\/strong><\/p>\n\n\n
    \nval pi = 3.14159\n<\/pre><\/div>\n\n\n
    En este ejemplo, el valor pi<\/code> es inmutable. No se puede cambiar una vez que se ha asignado. Cualquier intento de modificar su valor generar\u00eda un error de compilaci\u00f3n.<\/p>\n\n\n\n
    Ejemplos en Java y Scala<\/h2>\n\n\n\n
    En los siguientes ejemplos extraidos del libro Grokking Functional Programming<\/a> se puede notar como el metodo replan<\/code> esta implementado de tal manera que hay mutaciones de valores:<\/p>\n\n\n
    \npublic class PlannerMutableJava {\n\n    public static void main(String[] args) {\n        List<String> plan = new ArrayList<>();\n        plan.add("Paris");\n        plan.add("Berlin");\n        plan.add("Krakow");\n        System.out.println(plan);\n\n        replan(plan, "Vienna", "Krakow");\n        System.out.println(plan);\n    }\n\n    static void replan(List<String> plan,\n                               String newCity,\n                               String beforeCity) {\n        int newCityIndex = plan.indexOf(beforeCity);\n        plan.add(newCityIndex, newCity);\n    }\n}\n<\/pre><\/div>\n\n\n
    Esto puede ser re escrito en Java de tal manera que el metodo replan<\/code> solo use valores inmutables:<\/p>\n\n\n
    \npublic class PlannerImmutableJava {\n\n    public static void main(String[] args) {\n        List<String> plan = new ArrayList<>();\n        plan.add("Paris");\n        plan.add("Berlin");\n        plan.add("Krakow");\n        System.out.println(plan);\n\n        List<String> plan2 = replan(plan, "Vienna", "Krakow");\n        System.out.println(plan2);\n    }\n\n    static List<String> replan(List<String> plan,\n                               String newCity,\n                               String beforeCity) {\n        int newCityIndex = plan.indexOf(beforeCity);\n        List<String> replanned = new ArrayList<>(plan);\n        replanned.add(newCityIndex, newCity);\n        return replanned;\n    }\n}\n<\/pre><\/div>\n\n\n
    Del mismo modo se puede tener en Scala:<\/p>\n\n\n
    \nobject PlannerImmutableScala extends App {\n\n  def replan(plan: List[String],\n             newCity: String,\n             beforeCity: String): List[String] = {\n    val beforeCityIndex = plan.indexOf(beforeCity)\n    val citiesBefore = plan.slice(0, beforeCityIndex)\n    val citiesAfter = plan.slice(beforeCityIndex, plan.size)\n    citiesBefore.appended(newCity).appendedAll(citiesAfter)\n  }\n\n  val plan: List[String] = List("Paris", "Berlin", "Krakow")\n  println(plan)\n\n  val plan2: List[String] = replan(plan, "Vienna", "Krakow")\n  println(plan2)\n\n}\n<\/pre><\/div>\n\n\n
    Conclusi\u00f3n:<\/h2>\n\n\n\n
    La inmutabilidad es una pr\u00e1ctica esencial en Scala y en la programaci\u00f3n funcional en general. Al utilizar objetos inmutables, evitamos efectos secundarios inesperados, simplificamos la concurrencia, facilitamos el razonamiento y el testing, y fomentamos la reutilizaci\u00f3n de c\u00f3digo. Los ejemplos proporcionados ilustran c\u00f3mo podemos aplicar la inmutabilidad en diferentes contextos en Scala. Al adoptar la inmutabilidad como principio de dise\u00f1o, podemos construir c\u00f3digo m\u00e1s robusto, confiable y f\u00e1cilmente mantenible.<\/p>\n","protected":false},"excerpt":{"rendered":"
    En el desarrollo de software, la inmutabilidad es un concepto clave en el paradigma de programaci\u00f3n funcional y<\/p>\n","protected":false},"author":1,"featured_media":62,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[42,3],"tags":[45,44,8],"class_list":["post-215","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-funciontal","category-scala","tag-functional-programming","tag-immutability","tag-scala"],"_links":{"self":[{"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/215","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=215"}],"version-history":[{"count":5,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/215\/revisions"}],"predecessor-version":[{"id":221,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/posts\/215\/revisions\/221"}],"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=215"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/categories?post=215"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/canessaalvamiguel.dev\/index.php\/wp-json\/wp\/v2\/tags?post=215"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}