¿Qué es una mónada?

Primero: el término mónada es un poco vago si no eres matemático. Un término alternativo es generador de cálculos , que describe un poco más para qué son realmente útiles.

Son un patrón para encadenar operaciones. Se parece un poco al encadenamiento de métodos en los lenguajes orientados a objetos, pero el mecanismo es ligeramente diferente.

El patrón se usa principalmente en lenguajes funcionales (especialmente Haskell, que usa mónadas de manera generalizada), pero se puede usar en cualquier lenguaje que admita funciones de orden superior (es decir, funciones que pueden tomar otras funciones como argumentos).

Las matrices en JavaScript admiten el patrón, así que usémoslo como primer ejemplo.

La esencia del patrón es que tenemos un tipo ( Arrayen este caso) que tiene un método que toma una función como argumento. La operación proporcionada debe devolver una instancia del mismo tipo (es decir, devolver un Array).

Primero, un ejemplo de encadenamiento de métodos que no utiliza el patrón de mónada:

[1,2,3].map(x => x + 1)

El resultado es [2,3,4]. El código no se ajusta al patrón de mónada, ya que la función que proporcionamos como argumento devuelve un número, no una matriz. La misma lógica en forma de mónada sería:

[1,2,3].flatMap(x => [x + 1])

Aquí proporcionamos una operación que devuelve un Array, por lo que ahora se ajusta al patrón. El flatMapmétodo ejecuta la función proporcionada para cada elemento de la matriz. Espera una matriz como resultado para cada invocación (en lugar de valores únicos), pero fusiona el conjunto de matrices resultante en una única matriz. Entonces el resultado final es el mismo, la matriz [2,3,4].

(El argumento de función proporcionado a un método como mapo flatMapa menudo se denomina "devolución de llamada" en JavaScript. Lo llamaré "operación" ya que es más general).

Si encadenamos múltiples operaciones (de la forma tradicional):

[1,2,3].map(a => a + 1).filter(b => b != 3)

Resultados en la matriz[2,4]

El mismo encadenamiento en forma de mónada:

[1,2,3].flatMap(a => [a + 1]).flatMap(b => b != 3 ? [b] : [])

Produce el mismo resultado, la matriz [2,4].

¡Notarás inmediatamente que la forma mónada es bastante más fea que la no mónada! Esto simplemente demuestra que las mónadas no son necesariamente "buenas". Son un patrón que a veces es beneficioso y otras no.

Tenga en cuenta que el patrón de mónada se puede combinar de otra manera:

[1,2,3].flatMap(a => [a + 1].flatMap(b => b != 3 ? [b] : []))

Aquí el enlace está anidado en lugar de encadenado, pero el resultado es el mismo. Ésta es una propiedad importante de las mónadas, como veremos más adelante. Esto significa que dos operaciones combinadas pueden tratarse igual que una sola operación.

La operación puede devolver una matriz con diferentes tipos de elementos, por ejemplo transformando una matriz de números en una matriz de cadenas o algo más; siempre que siga siendo una matriz.

Esto se puede describir de manera un poco más formal usando la notación mecanografiada. Una matriz tiene el tipo Array<T>, donde Tes el tipo de los elementos de la matriz. El método flatMap()toma un argumento de función del tipo T => Array<U>y devuelve un archivo Array<U>.

Generalizado, una mónada es cualquier tipo Foo<Bar>que tenga un método "bind" que toma un argumento de función de tipo Bar => Foo<Baz>y devuelve un archivo Foo<Baz>.

Esto responde qué son las mónadas. El resto de esta respuesta intentará explicar mediante ejemplos por qué las mónadas pueden ser un patrón útil en un lenguaje como Haskell que tiene un buen soporte para ellas.

Haskell y notación Do

Para traducir el ejemplo de mapa/filtro directamente a Haskell, reemplazamos flatMapcon el >>=operador:

[1,2,3] >>= \a -> [a+1] >>= \b -> if b == 3 then [] else [b] 

El >>=operador es la función de enlace en Haskell. Hace lo mismo que flatMapen JavaScript cuando el operando es una lista, pero está sobrecargado con significados diferentes para otros tipos.

Pero Haskell también tiene una sintaxis dedicada para expresiones de mónada, el dobloque -, que oculta por completo el operador de vinculación:

do 
  a <- [1,2,3] 
  b <- [a+1] 
  if b == 3 then [] else [b] 

Esto oculta la "plomería" y le permite centrarse en las operaciones reales aplicadas en cada paso.

En un dobloque, cada línea es una operación. La restricción aún mantiene que todas las operaciones en el bloque deben devolver el mismo tipo. Dado que la primera expresión es una lista, las otras operaciones también deben devolver una lista.

La flecha hacia atrás <-parece engañosamente una asignación, pero tenga en cuenta que este es el parámetro pasado en el enlace. Entonces, cuando la expresión del lado derecho es una Lista de números enteros, la variable del lado izquierdo será un único número entero, pero se ejecutará para cada número entero de la lista.

Ejemplo: Navegación segura (del tipo Quizás)

Ya basta de listas, veamos cómo el patrón de mónada puede ser útil para otros tipos.

Es posible que algunas funciones no siempre devuelvan un valor válido. En Haskell esto está representado por el Maybetipo, que es una opción que es Just valueo Nothing.

Por supuesto, encadenar operaciones que siempre devuelven un valor válido es sencillo:

streetName = getStreetName (getAddress (getUser 17)) 

Pero, ¿qué pasaría si alguna de las funciones pudiera regresar Nothing? Necesitamos verificar cada resultado individualmente y solo pasar el valor a la siguiente función si no es así Nothing:

case getUser 17 of
      Nothing -> Nothing 
      Just user ->
         case getAddress user of
            Nothing -> Nothing 
            Just address ->
              getStreetName address

¡Muchos controles repetitivos! Imagínese si la cadena fuera más larga. Haskell resuelve esto con el patrón de mónada para Maybe:

do
  user <- getUser 17
  addr <- getAddress user
  getStreetName addr

Este dobloque invoca la función de vinculación para el Maybetipo (ya que el resultado de la primera expresión es a Maybe). La función de vinculación solo ejecuta la siguiente operación si el valor es Just value; de lo contrario, simplemente pasa la Nothingsiguiente operación.

Aquí se utiliza el patrón de mónada para evitar código repetitivo. Esto es similar a cómo otros lenguajes usan macros para simplificar la sintaxis, aunque las macros logran el mismo objetivo de una manera muy diferente.

Tenga en cuenta que es la combinación del patrón de mónada y la sintaxis compatible con mónadas en Haskell lo que da como resultado un código más limpio. En un lenguaje como JavaScript sin soporte de sintaxis especial para mónadas, dudo que el patrón de mónada pueda simplificar el código en este caso.

Estado mutable

Haskell no admite estados mutables. Todas las variables son constantes y todos los valores inmutables. Pero el Statetipo se puede utilizar para emular programación con estado mutable:

add2 :: State Integer Integer
add2 = do
        -- add 1 to state
         x <- get
         put (x + 1)
         -- increment in another way
         modify (+1)
         -- return state
         get


evalState add2 7
=> 9

La add2función construye una cadena de mónadas que luego se evalúa con 7 como estado inicial.

Obviamente esto es algo que sólo tiene sentido en Haskell. Otros idiomas admiten estados mutables desde el primer momento. Haskell generalmente "opta por" las características del lenguaje: usted habilita el estado mutable cuando lo necesita y el sistema de tipos garantiza que el efecto sea explícito. IO es otro ejemplo de esto.

OI

El IOtipo se utiliza para encadenar y ejecutar funciones "impuras".

Como cualquier otro lenguaje práctico, Haskell tiene un montón de funciones integradas que interactúan con el mundo exterior putStrLine: readLineetc. Estas funciones se denominan "impuras" porque causan efectos secundarios o tienen resultados no deterministas. Incluso algo tan simple como obtener la hora se considera impuro porque el resultado no es determinista: llamarlo dos veces con los mismos argumentos puede devolver valores diferentes.

Una función pura es determinista: su resultado depende exclusivamente de los argumentos pasados ​​y no tiene efectos secundarios en el medio ambiente además de devolver un valor.

Haskell fomenta fuertemente el uso de funciones puras; este es un importante punto de venta del lenguaje. Desafortunadamente para los puristas, se necesitan algunas funciones impuras para hacer algo útil. El compromiso de Haskell es separar limpiamente lo puro de lo impuro y garantizar que no haya forma de que funciones puras puedan ejecutar funciones impuras, directa o indirectamente.

Esto se garantiza dando el IOtipo a todas las funciones impuras. El punto de entrada en el programa Haskell es la mainfunción que tiene el IOtipo, por lo que podemos ejecutar funciones impuras en el nivel superior.

Pero, ¿cómo evita el lenguaje que funciones puras ejecuten funciones impuras? Esto se debe a la naturaleza perezosa de Haskell. Una función sólo se ejecuta si su salida es consumida por alguna otra función. Pero no hay forma de consumir un IOvalor excepto asignárselo main. Entonces, si una función quiere ejecutar una función impura, debe estar conectada mainy tener el IOtipo.

El uso del encadenamiento de mónadas para operaciones IO también garantiza que se ejecuten en un orden lineal y predecible, al igual que las declaraciones en un lenguaje imperativo.

Esto nos lleva al primer programa que la mayoría de la gente escribirá en Haskell:

main :: IO ()
main = do 
        putStrLn ”Hello World”

La dopalabra clave es superflua cuando solo hay una operación y, por lo tanto, no hay nada que vincular, pero la mantengo de todos modos por coherencia.

El ()tipo significa "vacío". Este tipo de retorno especial solo es útil para funciones IO solicitadas por su efecto secundario.

Un ejemplo más largo:

main = do
    putStrLn "What is your name?"
    name <- getLine
    putStrLn ("hello" ++ name)

Esto crea una cadena de IOoperaciones y, dado que están asignadas a la mainfunción, se ejecutan.

La comparación IOcon Maybemuestra la versatilidad del patrón de mónada. Para Maybe, el patrón se utiliza para evitar código repetitivo moviendo la lógica condicional a la función de enlace. Para IO, el patrón se utiliza para garantizar que todas las operaciones del IOtipo estén secuenciadas y que IOlas operaciones no puedan "filtrarse" a funciones puras.

Resumiendo

En mi opinión subjetiva, el patrón de mónada sólo vale la pena en un lenguaje que tenga algún soporte incorporado para el patrón. De lo contrario, sólo conducirá a un código demasiado complicado. Pero Haskell (y algunos otros lenguajes) tienen algún soporte incorporado que oculta las partes tediosas, y luego el patrón se puede usar para una variedad de cosas útiles. Como:

• Evitar código repetitivo ( Maybe)
• Agregar características de lenguaje como estado mutable o excepciones para áreas delimitadas del programa.
• Aislar cosas repugnantes de cosas buenas ( IO)
• Idiomas integrados específicos de dominio ( Parser)
• Añadiendo GOTO al idioma.

Oct 11 '2008 15:10 JacquesB