Mónadas

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

---

r8vnhill/functional-programming-kt

---

Be lazy...

Puedes ejecutar el siguiente comando para crear el módulo

./gradlew setupMonadsModule

Mientras se crean los archivos necesarios, puedes leer el código para saber qué está pasando.

Preocúpate de que el plugin monads esté aplicado en el archivo build.gradle.kts de tu proyecto.

./gradlew setupMonadsModule

Preocúpate de que el nuevo módulo esté incluido en el archivo settings.gradle.kts.

Mónada

---

Una Mónada es una abstracción en la teoría de categorías que extiende el concepto de un functor, permitiendo no solo mapear una función sobre una estructura de datos, sino también encadenar operaciones dependientes de forma secuencial. En programación funcional, una mónada es un tipo que implementa dos operaciones clave: $\mathrm{pure}$ (también conocida como $\mathrm{unit}$ o $\mathrm{return}$), que introduce un valor en la estructura monádica, y $\mathrm{flatMap}$ (también conocida como $\mathrm{bind}$), que aplica una función que devuelve otra estructura monádica, aplastando la estructura resultante para evitar anidaciones.

Corolario

Si tienes una estructura como Option, List o Result, y puedes encadenar operaciones sin preocuparte por valores vacíos, errores o el manejo explícito de efectos, entonces estás utilizando una mónada. Las mónadas permiten manejar flujos de operaciones de manera segura y ordenada.

Leyes de las Mónadas

Para que una estructura sea considerada una mónada, debe cumplir con las siguientes tres leyes fundamentales. Estas leyes aseguran la coherencia de las operaciones monádicas y permiten el encadenamiento predecible de transformaciones.

1. Ley de Identidad Izquierda: Si aplicamos la función de $\mathrm{pure}$ a un valor y luego lo encadenamos con una función $f$ mediante $\mathrm{flatMap}$, debe ser equivalente a aplicar directamente $f$ al valor.

   $\mathrm{pure}(x) \, \mathrm{flatMap} \, f = f(x)$

   Intuición: Tomar un valor, envolverlo en una mónada y luego aplicar una función f debe ser lo mismo que aplicar f directamente al valor.

2. Ley de Identidad Derecha: Si tenemos una mónada $m$ y la encadenamos con la función $\mathrm{pure}$ mediante $\mathrm{flatMap}$, el resultado debe ser la misma mónada $m$.

   $m \, \mathrm{flatMap} \, \mathrm{pure} = m$

   Intuición: Encadenar una mónada con la función que simplemente envuelve su valor original no debe cambiar la mónada.

3. Ley de Asociatividad: Encadenar múltiples aplicaciones de funciones debe ser asociativo. Si encadenamos una secuencia de operaciones con $\mathrm{flatMap}$, el orden en que se agrupan las funciones no debe afectar el resultado.

   $(m \, \mathrm{flatMap} \, f) \, \mathrm{flatMap} \, g = m \, \mathrm{flatMap} \, (\lambda x. f(x) \, \mathrm{flatMap} \, g)$

   Intuición: Encadenar primero $f$ y luego $g$ es lo mismo que primero aplicar $f$, y luego encadenar $g$ al resultado de $f$, sin importar cómo agrupemos las operaciones.

Estas leyes aseguran que las mónadas respeten un comportamiento coherente y predecible al trabajar con efectos y transformaciones encadenadas, garantizando que el flujo de operaciones sea estable independientemente del orden en el que se apliquen las transformaciones.

Caso de estudio: Mónada Box

Creando la Clase Box

Al igual que con los functores, comenzaremos con una estructura simple llamada Box que encapsula un valor y nos permitirá implementar las operaciones monádicas.

monads/src/main/kotlin/com/github/username/monads/Box.kt

package com.github.username

data class Box<out A>(val value: A)

Implementando la mónada para Box

monads/src/main/kotlin/com/github/username/monads/BoxMonad.kt

package com.github.username.monads

object BoxMonad {
    fun <A> pure(a: A): Box<A> = Box(a)
    fun <A, B> Box<A>.flatMap(f: (A) -> Box<B>): Box<B> = f(value)
}

¿Qué acabamos de hacer?

La implementación de la mónada Box consta de dos funciones:

• pure: Toma un valor de tipo A y lo envuelve en una caja Box.
• flatMap: Toma una función f que mapea un valor de tipo A a una caja Box<B>. Extrae el valor de la caja actual y aplica la función f para obtener una nueva caja Box<B>.

Verificando las leyes de las mónadas

Vamos a escribir pruebas para verificar que nuestra implementación de BoxMonad cumple con las leyes de las mónadas.

Código esencial

Ley de identidad izquierda

checkAll(Arb.int(), Arb.int()) { a, b ->
    val f: (Int) -> Box<Int> = { Box(it * b) }
    BoxMonad.run {
        pure(a).flatMap(f) shouldBe f(a)
    }
}

Ley de identidad derecha

checkAll(Arb.int()) { a ->
    BoxMonad.run {
        pure(a).flatMap { pure(it) } shouldBe pure(a)
    }
}

Ley de asociatividad

checkAll(Arb.int(), Arb.int(), Arb.int()) { a, b, c ->
    val f: (Int) -> Box<Int> = { Box(it * b) }
    val g: (Int) -> Box<Int> = { Box(it + c) }
    BoxMonad.run {
        pure(a).flatMap(f).flatMap(g) shouldBe 
            pure(a).flatMap { f(it).flatMap(g) }
    }
}

Código completo

package cl.ravenhill.monads

import io.kotest.core.spec.style.FreeSpec
import io.kotest.matchers.shouldBe
import io.kotest.property.Arb
import io.kotest.property.arbitrary.int
import io.kotest.property.checkAll

class BoxMonadTest : FreeSpec({
    "Given a box monad" - {
        // Left identity
        "when wrapping a value in the monadic context" - {
            ("then chaining a function should be the same as applying the " +
                    "function to the value"){
                checkAll(Arb.int(), Arb.int()) { a, b ->
                    val f: (Int) -> Box<Int> = { Box(it * b) }
                    BoxMonad.run {
                        pure(a).flatMap(f) shouldBe f(a)
                    }
                }
            }
        }

        // Right identity
        "when chaining a function that returns the monadic context" - {
            ("then the result should be the same as the original monadic " +
                    "context") {
                checkAll(Arb.int()) { a ->
                    BoxMonad.run {
                        pure(a).flatMap { pure(it) } shouldBe pure(a)
                    }
                }
            }
        }

        // Associativity
        "when chaining two functions" - {
            ("then the result should be the same as chaining the result of " +
                    "the first function with the second") {
                checkAll(Arb.int(), Arb.int(), Arb.int()) { a, b, c ->
                    val f: (Int) -> Box<Int> = { Box(it * b) }
                    val g: (Int) -> Box<Int> = { Box(it + c) }
                    BoxMonad.run {
                        pure(a).flatMap(f).flatMap(g) shouldBe
                                pure(a).flatMap { f(it).flatMap(g) }
                    }
                }
            }
        }
    }
})

Beneficios y limitaciones de las mónadas

Beneficios

• Manejo seguro de efectos: Las mónadas permiten encapsular efectos como errores, valores ausentes o flujos asincrónicos, lo que evita errores comunes como null o excepciones no controladas. Esto aumenta la robustez y la seguridad del código.
• Encadenamiento limpio de operaciones: Gracias a flatMap, las operaciones dependientes pueden encadenarse de forma secuencial, manteniendo el código conciso y fácil de seguir.
• Reutilización y componibilidad: Las mónadas facilitan la creación de estructuras reutilizables y componibles, permitiendo que las funciones se manejen de manera coherente sin importar el tipo de efecto (por ejemplo, valores opcionales, listas, o resultados de operaciones).
• Control explícito de errores: Con estructuras como Option o Either, las mónadas ayudan a hacer explícito el manejo de errores y valores ausentes, mejorando la legibilidad y evitando errores inesperados en el flujo de ejecución.

Limitaciones

• Complejidad conceptual: El concepto de las mónadas puede resultar abstracto y difícil de entender para personas sin experiencia en programación funcional, ya que introduce un nuevo paradigma de manipulación de efectos.
• Propagación del tipo monádico: Al usar mónadas, las funciones deben adaptarse para devolver valores en el mismo contexto monádico, lo que puede requerir cambios significativos en el código si se introduce en un sistema sin una estructura funcional previa.
• Rendimiento en ciertos contextos: En algunos casos, especialmente en estructuras monádicas anidadas o en aplicaciones de bajo nivel, el uso extensivo de mónadas puede introducir una sobrecarga en términos de rendimiento o memoria.
• Limitaciones de control de flujo: Las mónadas encapsulan operaciones secuenciales, lo que puede dificultar el uso en estructuras de control de flujo más complejas (por ejemplo, bucles o condiciones) sin reestructurar el código de manera funcional.

¿Qué aprendimos?

En esta lección, exploramos el concepto de mónadas en programación funcional y sus aplicaciones prácticas para manejar flujos de datos y efectos de manera segura y estructurada. Vimos que las mónadas son una abstracción poderosa que permite realizar operaciones secuenciales sobre datos y efectos sin comprometer la seguridad o claridad del código.

Puntos clave

1. Manejo de efectos con seguridad: Las mónadas nos permiten encapsular efectos como errores y valores opcionales en un contexto seguro, mejorando la robustez del código al reducir errores comunes.
2. Encadenamiento y composición: Con operaciones como flatMap, es posible encadenar funciones de manera limpia y sin anidación excesiva, lo que facilita la comprensión y la mantenibilidad del código.
3. Leyes monádicas: Las leyes de identidad y asociatividad garantizan que las operaciones sobre mónadas se comporten de manera coherente y predecible, manteniendo la estabilidad del flujo de operaciones.
4. Balance entre beneficios y limitaciones: Aunque las mónadas ofrecen grandes ventajas en términos de manejo seguro de efectos y estructura del código, también introducen una complejidad conceptual y pueden tener sobrecargas de rendimiento en ciertos contextos.

---

Con este conocimiento, podemos tomar decisiones informadas sobre cuándo y cómo utilizar mónadas en nuestros proyectos, especialmente en escenarios donde el manejo seguro de efectos y la composición de funciones es crucial. Las mónadas, al igual que otras abstracciones funcionales, nos brindan herramientas efectivas para estructurar aplicaciones complejas y mantenibles.

Haskell

Scala

Bibliografías Recomendadas

• 📚 "Monads and functors". (2021). Marco Vermeulen, Rúnar Bjarnason, Paul Chiusano, en Functional Programming in Kotlin, (pp. 231–257.) Manning Publications Co. LLC.