Mónada (programación funcional)

Considérese al opción de tipo Maybe a (“tal vez un”), representando un valor que es o un valor del tipo a , o ninguno. Para distinguirlos, se tienen dos constructores de tipo de dato algebraico: Just t, conteniendo el valor t, o Nothing, sin contenido.

data Maybe t = Just t | Nothing

Nos gustaría poder usar este tipo como una simple excepción chequeada: en cualquier punto del cómputo, este puede fallar, lo que causa que el resto del proceso sea saltado y que el resultado final sea Nothing. Si todos los pasos del cómputo son exitosos, entonces el resultado final es Just x para un valor x.

En el siguiente ejemplo, suma es una función que toma dos argumentos del tipo Maybe int, y regresa un resultado del mismo tipo. Si ambas mx y my tienen valores Just, queremos regresar Just su suma; pero si mx o my son Nothing, queremos regresar Nothing. Si se intentara escribir funciones con este tipo de conducta, se terminaría con una serie de casos “if Nothing then Nothing else something with x in Just x” que rápidamente se volverían confusos:[1]

suma :: Maybe Int -> Maybe Int -> Maybe Int
suma mx my =
  case mx of
    Nothing -> Nothing
    Just x   -> case my of
                  Nothing -> Nothing
                  Just y  -> Just (x + y)

Para aliviar esto, podemos definir operaciones para encadenar tales cómputos de manera conjunta. El operador binario bind (“unir”) (>>=) encadena los resultados de un cómputo que pudiera fallar, a una función que elige otro cómputo que pudiera fallar. Si el argumento es Nothing (“nada”), el segundo argumento (la función) es ignorada y la operación entera simplemente falla. Si el argumento es Just x (“solo x”), pasamos x a la función para obtener un nuevo valor Maybe, que puede o no ser el resultado en un valor del tipo Just (“solo”).

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
Nothing >>= _ = Nothing -- Un cómputo fallido regresa Nada
(Just x) >>= f = f x -- Aplica la función f al valor x

Usando un poco de azúcar sintáctico, conocida como notación do, el ejemplo puede ser escrito como:

suma :: Maybe Int -> Maybe Int -> Maybe Int
suma mx my = do
  x <- mx
  y <- my
  return (x + y)

Dado que este tipo de operación es muy común, existe una función estándar en Haskell (liftM2) que toma dos valores mónadicos (aquí: dos Maybes) y combina sus contenidos (dos números) usando otra función (adición), haciendo posible escribir el ejemplo pasado como:

add :: Maybe Int -> Maybe Int -> Maybe Int
add = liftM2 (+)

La mónada escritora permite que un proceso lleve información adicional “al lado” de su valor de cómputo. Esto puede ser útil para el registro de errores o el debugging de la información que no es el resultado primario.[10]

El siguiente ejemplo implementa la mónada escrita en JavaScript:

Primero, una mónada escritora es definida. La función unidad crea un nuevo tipo de valor de un tipo básico, el cual lleva una cadena de registro; y bind aplica la función a un valor viejo, y finalmente regresa el nuevo valor de resultado con un registro expandido. Los corchetes trabajan aquí como el constructor de tipo de la mónada, creando un valor de tipo mónadico para la mónada escritora, hecha de componentes más simples (el valor en la posición 0 del arreglo, y la cadena de registro en la posición 1).

var unit = function (value) { return [value, ''] };

var bind = function (valorMonadico, transformaConRegistro) {
    var value    = valorMonadico[0],
        registro = valorMonadico[1],
        result   = transformaConRegistro(value);
    return [result[0], registro + result[1]];
};

Tubería es una función auxiliar que concatena una secuencia de binds aplicados a un arreglo de funciones.

var pipeline = function (monadicValue, functions) {
    for (var key in functions) {
        monadicValue = bind(monadicValue, functions[key]);
    }
    return monadicValue;
};

Ejemplos de funciones que regresen valores del tipo esperados por la mónada escritora de arriba:

var squared = function (x) {
    return [x * x, 'al cuadrado.'];
};

var halved = function (x) {
    return [x / 2, 'a la mitad.'];
};

Finalmente, un ejemplo del uso de la mónada para crear una tubería de funciones matemáticas, con información de debug al lado.

pipeline(unit(4), [squared, halved]); // [8, "al cuadrado.a la mitad"]

En un lenguaje puramente funcional, como Haskell, las funciones no pueden tener efectos externos visibles como parte de la semántica de la función. Aunque una función no puede directamente causar un efecto, puede construir un valor describiendo un efecto deseado, que el llamante puede aplicar a un tiempo conveniente. .[11] En la notación Haskell, un valor de tipo IO a representa una acción que, a la hora de ser realizada , produce un valor de tipo a'.

Podemos pensar en un valor de tipo IO como una acción que toma como su argumento el estado actual del mundo, y que regresara un nuevo mundo donde el estado ha sido cambiado de acuerdo al valor de retorno de la función. Por ejemplo, las funciones doesFileExist (existe el archivo?) y removeFile (remueve el archivo) en la librería estándar de Haskell tienen los siguientes tipos

doesFileExist :: FilePath -> IO Bool
removeFile :: FilePath -> IO ()

Así que uno puede pensar removeFile como una función que, dado un FilePath, regresa una acción IO ; esta acción se encargará de que el mundo, en este caso el sistema de archivos, no tendrá un archivo nombrado por tal FilePath cuando sea ejecutado. Aquí el valor interno IO es del tipo () que significa que el llamante no está interesado en otros resultados. Por otra parte, en doesFileExist, la función regresa una acción IO que envuelve a un valor booleano True o False; esto conceptualmente representa un nuevo estado del mundo donde el llamante sabe por cierto que un FilePath está presente o no dentro del sistema de archivos en el momento que la acción fue realizada. El estado del mundo manejado de esta manera puede ser pasado de acción a acción, y de tal manera definir una serie de acciones que serán aplicadas en orden de pasos de cambio de estados. Este proceso es similar a como la lógica temporal representa el paso del tiempo usando solo proposiciones declarativas. El siguiente ejemplo clarifica en detalle como este encadenamiento de acciones ocurre en un programa.

Nos gustaría ser capaces de describir todos los tipos básicos de operaciones I/O, por ejemplo, escribir texto a una salida estándar, leer de una entrada estándar, leer y editar archivos, mandar datos sobre redes, etc. En adicipon, necesitamos ser capaces de componer estas primitivas para formar programas más grandes. Por ejemplo, nos gustaría escribir :

main :: IO ()
main = do
  putStrLn "Cual es tu nombre?"
  name <- getLine
  putStrLn ("Gusto en conocerte, " ++ name ++ "!")

¿Cómo formalizar esta notación intuitiva? Para hacerlo, necesitamos ser capaces de realizar operaciones básicas de I/O:

• Debemos poder secuenciar dos operaciones I/O. En Haskell, esto es escrito como el operador infix >>, de tal manera que putStrLn "abc" >> putStrLn "def" sea un acción I/O que imprima dos líneas de texto hacia la consola. El tipo de >> es IO a → IO b → IO b, significando que el operador toma dos operaciones I/O y regresa una tercera que secualiza las dos y regresa el valor de la segunda.
• Debemos tener una acción I/O que haga nada. Es decir, regrese un valor pero no tenga efectos. En Haskell, este constructor es llamado return; tiene tipo a → IO a.
• Más sútilmente, deberíamos poder determinar nuestra próxima acción basado en los resultados de la acción previa. Para hacer esto, Haskell tiene un operador >>= (pronunciado bind) con tipo IO a → (a → IO b) → IO b. Es decir, el operando de la izquierda es una acción I/O que regresa un valor del tipo a; el operando en la derecha es una función que puede tomar un acción I/O basada en el valor producido por la acción de la izquierda. La acción resultante combinada, al ser realizada, hace la primera acción, después evalúa la función con el valor de regreso de la primera y después realiza la segunda acción, finalmente regresa el valor de la segunda acción.

Un ejemplo del uso de este operador en Haskell sería getLine >>= putStrLn, el cual lee una sola línea de texto de una entrada estándar y la manda a la salida estándar. Notar que el primer operador, >>, es solo un caso especial de este operador en el que el valor de regreso de la primera acción es ignorado y la segunda acción seleccionada es siempre la misma.

No es necesariamente obvio que las tres operaciones precedentes, junto con set de operaciones I/O nos ayudan a definir cualquier acción de programa, incluyendo las transformaciones de datos, control de flujo y control de flujo recursivo. Podemos escribir el ejemplo de arriba como una sola expresión.

main =
  putStrLn "Cual es tu nombre?" >> 
  getLine >>= \name ->
  putStrLn ("Gusto en conocerte " ++ name ++ "!")

La estructura de tubería del operador bind se asegura de que 'getLine y putStrLn sean evaluadas una sola vez y en el orden requerido, para que así los efectos de extraer el texto de la entrada y escribir a la salida sean correctamente ejecutadas en la tubería funcional. Esto permanece cierto aun si el lenguaje realiza evaluación de funciones fuera de orden o una evaluación perezosa.

Claramente , existe una estructura común entre las definiciones I/O y las Maybe, aun si son diferentes en muchas maneras. Las mónadas son una abstracción de las estructuras antes descritas, de estructuras similares y de sus semejanzas. El concepto general de mónadas incluye una situación donde el programador quiere llevar a cabo un cómputo puramente funcional mientras que un cómputo relacionado se lleva a cabo al lado.

Para que una mónada se comporte de la manera correcta, sus definiciones deben seguir ciertos axiomas, los cuales en su conjunto son llamados leyes mónadicas.[12] El símbolo ≡ indica equivalencia entre dos expresiones de Haskell en el siguiente texto.

• return actúa aproximadamente como un elemento neutral de >>=, en que:

  • (return x) >>= f ≡ f x
    

  • m >>= return ≡ m
    

• El unir dos funciones en sucesión es lo mismo que unir una función que puede ser determinada desde ellas:

  • (m >>= f) >>= g ≡ m >>= ( \x -> (f x >>= g) )
    

Los axiomas también pueden ser mostrados usando las expresiones en la notación-do:

• do { f x } ≡ do { v <- return x; f v }
  

• do { m } ≡ do { v <- m; return v }
  

• do { x <- m; y <- f x; g y } ≡ do { y <- do { x <- m; f x }; g y }
  

o usando el operador monádico de composición,

(f >=> g) x = (f x) >>= g

:

• return >=> g ≡ g
  

• f >=> return ≡ f
  

• (f >=> g) >=> h ≡ f >=> (g >=> h)
  

Aunque Haskell define a las mónadas en términos de las funciones return y union, también es posible definir una mónada en términos de retorno y otras dos operaciones, join (juntar) y fmap. Esta formulación se encuentra más apegada con la definición de mónadas en la teoría de categorías. La operación fmap, con tipo (t→u) → M t→M u,[13] toma una función entre 2 tipos y produce una función que hace la misma cosa a los valores en la mónada. La operación join, con tipo M (M t)→M t, aplana dos capas de información mónadica en una sola.

Las dos formulaciones son mostradas:

fmap f m = m >>= (return . f)
join n = n >>= id

m >>= g ≡ join (fmap g m)

Aquí, m tiene el tipo M t,n tiene el tipo M ( M r), f tiene el tipo t → u, y g tiene el tipo t → M v, donde t, r, u y v son tipos subyacentes.

La función retorno caracteriza los funtores apuntados en la misma categoría, usando para esto la habilidad de cargar valores en el funtor. Se debe satisfacer la siguiente ley:

return . f ≡ fmap f . return

En adición , la función join caracteriza las mónadas:

join . fmap join = join . join
join . fmap return = join . return = id
join . fmap (fmap f) = fmap f . join

Una mónada aditiva es una mónada provista con un cero mónadico mzero y un operador binario mplus que satisface las leyes mónadicas, usando el cero mónadico como unidad. El operador mplus tiene el tipo M t → M t → M t (donde M es el constructor mónadico y t es el tipo de dato subyacente), satisface la ley asociativa y tiene el cero como identidad en la izquierda y la derecha. (Por lo tanto, una mónada aditiva es también un monoide).

El unir el mzero con cualquier función produce el cero para el tipo de resultado, justo como el multiplicar 0 por cualquier número da 0.

mzero >>= f ≡ mzero

Similarmente, unir cualquier m con una función que siempre devuelve un 0, resulta en un 0.

m >>= (\x -> mzero) ≡ mzero

Intuitivamente, el cero representa un valor en la mónada que tiene una estructura exclusivamente relacionada con la mónada y que no tiene valores de tipo subyacente. En la mónada Maybe, Nothing (Nada) es un cero. En la mónada Lista, [ ] (la lista vacía) es también un cero.

La mónada más simple es la mónada identidad, la cual no añade información a los valores.

Id t = t
return x = x
x >>= f = f x

Un bloque-do en esta mónada realiza substitución de variables; do {x <- 2; return 3*x} resulta en 6.

Desde el punto de vista de la teoría de categorías, la mónada identidad deriva de la unión entre funtores identidad.

Algunos tipos familiares de colección, incluyendo las listas, los sets y multisets, son mónadas. La definición para las listas están dadas aquí.

-- "return" construye una lista de un elemento
return x = [x]
-- "bind" concatena las listas obtenidas al aplicar f a cada elemento en la lista xs
xs >>= f = concat (map f xs)
-- El objeto cero es una lista vacía
mzero = []

Las listas de comprensión, son un aplicación especial de la mónada lista. Por ejemplo, la lista comprensión [ 2*x | x <- [1..n], isOkay x] corresponde al cómputo en la mónada lista do {x <- [1..n]; if isOkay x then return (2*x) else mzero;}.

La notación de listas por comprensión es similar a la notación de constructor de conjunto, pero un conjunto no puede ser convertido en una mónada, ya que hay una restricción en el tipo de cómputo a ser comparable por igualdad, mientras que una mónada no pone ninguna restricción en los tipos de cómputo. De hecho, el conjunto es una mónada restringida.[14]

Las mónadas de colecciones representan naturalmente un algoritmo no determinista. La lista (u otra colección) representa todos los posibles resultados de diferentes caminos no determinísticos de cómputo en ese momento. Por ejemplo, cuando uno ejecuta x <- [1,2,3,4,5], uno dice que la variable x puede de manera no determinística tomar cualquiera de los valores de la lista. Si uno regresara x se evaluara con una lista de resultados de cada camino de cómputo. Nótese que el operador unión de arriba sigue tal tema al realizar f en cada uno de los resultados posibles y después concatena las listas resultantes.

Las declaraciones como if condition x y then return () else mzero son usualmente vistas; si la condición es verdad, la opción no determinística se realiza desde un camino dummy de cómputo, el cual regresa un valor que no asignamos a nada; sin embargo, si la condición es falsa, entonces la mónada de valor no determinístico mzero = [] escoge desde 0 valores, terminando así efectivamente tal camino de cómputo. Otros caminos de cómputo pueden todavía tener éxito. Esto sirve como una guarda para asegurar que solo los caminos de cómputo que satisfacen ciertas condiciones puedan continuar. Así que las mónadas colección son muy útiles para resolver puzles lógicos, Sudoku, y problemas similares.

En un lenguaje con evaluación perezosa, como Haskell, una lista es evaluada solo en el grado en que sus elementos son requeridos: por ejemplo, si uno pide el primer elemento de una lista, solo el primer elemento será computado. Con respecto al uso de la mónada lista para cómputos no determinísticos, esto significa que podemos generar no determinísticamente una lista perezosa de todos los resultados del cómputo, después pedir el primero de ellos, y solo se realizará tanto trabajo sea necesario para obtener el primer resultado. El proceso vagamente corresponde a regresarse: un camino es escogido, después falla en cierto punto (si es que se evalúa mzero), posteriormente se regresa al último punto de ramificación, y sigue el otro camino, y así hasta terminar. Si el segundo elemento es pedido, se vuelve a hacer solo el trabajo necesario para obtener la segunda solución. De tal manera que la mónada lista es una manera sencilla de implementar un algoritmo de regreso en un lenguaje perezoso.

Desde el punto de vista de la teoría de las categorías, las mónadas colección son derivadas una unión de funtores entre uno libre y uno subyacente entre la categoría de conjuntos y la categoría de magma (categoría). Tomando diferentes tipos de magmas, obtenemos diferentes tipos de colecciones, como se muestra en la tabla de abajo:

Una mónada estado le permite a un programador añadir información de estado de cualquier tipo de cálculo. Dado cualquier tipo de valor, el tipo correspondiente en la mónada estado es una función la cual acepta estado y después regresa un nuevo estado (de tipo s) junto con un valor de retorno (de tipo t).

type State s t = s -> (t, s)

Nótese que en esta mónada, en comparación con las ya vistas, toma un parámetro tipo, o sea el estado de tipo de la información. Las operaciones de la mónada se definen de la siguiente manera:

-- "return" produce el valor dado sin cambiar el estado.
return x = \s -> (x, s)
-- "bind" modifica m para que aplique a f su resultado
m >>= f = \r -> let (x, s) = m r in (f x) s

Operaciones útiles de estado incluyen:

get = \s -> (s, s) – Examina el estado en este punto del cómputo
put s = \_ -> ((), s) – Reemplaza el estado
modify f = \s -> ((), f s) – Actualiza el estado

Otra operación aplica una mónada estado a un valor inicial dado:

runState :: State s a -> s -> (a, s)
runState t s = t s

Los bloques-do en una mónada estado son secuencias de operaciones que pueden examinar y actualizar los datos de estado.

Informalmente , una mónada estado de tipo S mapea el tipo de valores de retorno T en funciones de tipo ${\displaystyle S\rightarrow T\times S}$, donde S es el estado subyacente. La función return es simplemente:

${\displaystyle {\text{return}}\colon T\rightarrow S\rightarrow T\times S=t\mapsto s\mapsto (t,s)}$

La función bind (union) es:

${\displaystyle {\text{bind}}\colon (S\rightarrow T\times S)\rightarrow (T\rightarrow S\rightarrow T'\times S)\rightarrow S\rightarrow T'\times S}$${\displaystyle \ =m\mapsto k\mapsto s\mapsto (k\ t\ s')\quad {\text{where}}\;(t,s')=m\,s}$.

Desde el punto de vista de la teoría de las categorías, una mónada estado es derivada de la conjunción entre el funtor producto y el funtor exponencial, el cual existe en cualquier categoría cartesiana cerrada por definición.

La mónada ambiente (también llamada “mónada lectora” y “mónada función”) permite que un computo dependa de los valores de un ambiente compartido . El constructor de tipo de mónada mapea un tipo T a funciones de tipo E → T', donde E es el tipo del ambiente compartido. Las funciones mónadas son: ${\displaystyle {\text{return}}\colon T\rightarrow E\rightarrow T=t\mapsto e\mapsto t}$

${\displaystyle {\text{bind}}\colon (E\rightarrow T)\rightarrow (T\rightarrow E\rightarrow T')\rightarrow E\rightarrow T'=r\mapsto f\mapsto e\mapsto f\,(r\,e)\,e}$

Las siguiente operaciones monádicas son las siguientes:

${\displaystyle {\text{ask}}\colon E\rightarrow E={\text{id}}_{E}}$

${\displaystyle {\text{local}}\colon (E\rightarrow E)\rightarrow (E\rightarrow T)\rightarrow E\rightarrow T=f\mapsto c\mapsto e\mapsto c\,(f\,e)}$

La operación “ask” es usada para recuperar el contexto actual, mientras que local ejecuta una computación en un subcontexto modificado. Como en la mónada estado, los cómputos en la mónada ambiente pueden ser invocados al simplemente proveer un valor de ambiente y aplocarlo a una instancia de la mónada.

La mónada escritora le permite a un programa hacer computos de varios tipos de salidas auxiliares que pueden ser “compuestas” o “acumuladas” paso a paso, en adición al resultado general de la computación. Es usualmente requerida para capturar información. Dado el tipo subyacente T un valor en la mónada escritora tiene tipo W× T, donde W es un tipo con la operación adjuntada que satisface las leyes monóides. Las funciones mónadas son simplemente:

${\displaystyle {\text{return}}\colon T\rightarrow W\times T=t\mapsto (\epsilon ,t)}$

${\displaystyle {\text{bind}}\colon (W\times T)\rightarrow (T\rightarrow W\times T')\rightarrow W\times T'=(w,t)\mapsto f\mapsto (w*w',\,t')\quad {\text{where}}\;(w',t')=f\,t}$

donde ε y * son los elementos identidad del monoíde W y su operación asociada.

La operación mónadica “tell” está definida por: :${\displaystyle {\text{tell}}\colon W\rightarrow (W\times 1)=w\mapsto (w,())}$ Donde 1 y () denotan el tipo unidad y su elemento trivial. Es usada en combinación con bind para actualizar el valor auxiliar sin afectar el computo principal.

Una mónada continuación con tipo de retorno ${\displaystyle R}$ mapea el tipo ${\displaystyle T}$ en funciones de tipo ${\displaystyle \left(T\rightarrow R\right)\rightarrow R}$. Es usada para modelar el estilo de continuación de paso. Las funcinoes return y bind son las siguientes:

${\displaystyle {\text{return}}\colon T\rightarrow \left(T\rightarrow R\right)\rightarrow R=t\mapsto f\mapsto f\,t}$

${\displaystyle {\text{bind}}\colon \left(\left(T\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow \left(T'\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T'\rightarrow R\right)\rightarrow R}$${\displaystyle =c\mapsto f\mapsto k\mapsto c\,\left(t\mapsto f\,t\,k\right)}$

La función llamada con-continuación actual está definida de la siguiente manera:

${\displaystyle {\text{call/cc}}\colon \left(\left(T\rightarrow \left(T'\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow R\right)\rightarrow R}$${\displaystyle =f\mapsto k\mapsto \left(f\left(t\mapsto x\mapsto k\,t\right)\,k\right)}$

Otros conceptos que los investigadores han expresado como mónada incluyen:

• Manejo de excepciones
• Interfaz gráfica de usuario
• Analizador sintáctico
• Evaluación estricta
• Intérprete (informática)

Las co-mónadas son el dual categórico de las mónadas. Son definidas por un tipo de constructor W T y dos operaciones: extract (extraer) con tipo W T → T para cualquier T, y extend con tipo (W T → T' ) → W T → W T' . Las operaciones extract y extend deben satisfacer las leyes:

${\displaystyle {\text{extend}}\,\,{\text{extract}}={\text{id}}}$

${\displaystyle {\text{extract}}\circ ({\text{extend}}\,f)=f}$

${\displaystyle ({\text{extend}}\,f)\circ ({\text{extend}}\,g)={\text{extend}}\,(f\circ ({\text{extend}}\,g))}$

Alternativamente las co-mónadas pueden ser definidas en términos de las operacinoes fmap, extract y duplicate. Las operaciones fmap y extract definen W, como el funtor coapuntado. La operación duplicate caracteriza a las co-mónadas: Tiene el tipo W T → W (W T) y sastisface las siguientes leyes:

${\displaystyle {\text{extract}}\circ {\text{duplicate}}={\text{id}}}$

${\displaystyle {\text{fmap}}\,{\text{extract}}\circ {\text{duplicate}}={\text{id}}}$

${\displaystyle {\text{duplicate}}\circ {\text{duplicate}}={\text{fmap}}\,{\text{duplicate}}\circ {\text{duplicate}}}$

Las dos formulaciones son relacionadas de la siguiente manera:

${\displaystyle {\text{fmap}}:(A\rightarrow B)\rightarrow \mathrm {W} \,A\rightarrow \mathrm {W} \,B=f\mapsto {\text{extend}}\,(f\circ {\text{extract}})}$

${\displaystyle {\text{duplicate}}:\mathrm {W} \,A\rightarrow \mathrm {W} \,\mathrm {W} \,A={\text{extend}}\,{\text{id}}}$

${\displaystyle {\text{extend}}:(\mathrm {W} \,A\rightarrow B)\rightarrow \mathrm {W} \,A\rightarrow \mathrm {W} \,B=f\mapsto ({\text{fmap}}\,f)\circ {\text{duplicate}}}$

Mientras que las mónadas representan los efectos, una mónada W representa un tipo de contexto. Las funciones extract extraen un válor de éste contexto. Mientras que la función extend puede ser usada para componer una tubería de funciones dependientes del contexto de tipo W A → B.

La co-mónada identidad es la más simple de las co-mónadas: mapea el tipo T a sí mismo. El operador extract' es la identidad y el operador extend es la función de aplicación.

La co-mónada producto mapea el tipo ${\displaystyle T}$ en tuplas de tipo ${\displaystyle C\times T}$, donde ${\displaystyle C}$ es el tipo contexto de la co-mónada. Las operaciones co-mónadas son:

${\displaystyle {\text{extract}}:(C\times T)\rightarrow T=(c,t)\mapsto t}$

${\displaystyle {\text{extend}}:((C\times A)\rightarrow B)\rightarrow C\times A\rightarrow C\times B=f\mapsto (c,a)\mapsto (c,f\,(c,a))}$

${\displaystyle {\text{fmap}}:(A\rightarrow B)\rightarrow (C\times A)\rightarrow (C\times B)=(c,a)\mapsto (c,f\,a)}$

${\displaystyle {\text{duplicate}}:(C\times A)\rightarrow (C\times (C\times A))=(c,a)\mapsto (c,(c,a))}$

La función co-mónada mapea tipo ${\displaystyle T}$ en funciones de tipo ${\displaystyle M\rightarrow T}$, donde ${\displaystyle M}$ es un tipo de conjunto con estructura monoide. Las operaciones co-mónadas son:

${\displaystyle {\text{extract}}:(M\rightarrow T)\rightarrow T=f\mapsto f\,\varepsilon }$

${\displaystyle {\text{extend}}:((M\rightarrow A)\rightarrow B)\rightarrow (M\rightarrow A)\rightarrow M\rightarrow B=f\mapsto g\mapsto m\mapsto f\,(m'\mapsto g\,(m*m'))}$

${\displaystyle {\text{fmap}}:(A\rightarrow B)\rightarrow (M\rightarrow A)\rightarrow M\rightarrow B=f\mapsto g\mapsto (f\circ g)}$

${\displaystyle {\text{duplicate}}:(M\rightarrow A)\rightarrow M\rightarrow (M\rightarrow A)=f\mapsto m\mapsto m'\mapsto f\,(m*m')}$

donde ε es el elemento identidad de ${\displaystyle M}$ y * es la operación asociativa.

La co-mónada co-estado mapea a tipo ${\displaystyle T}$ en tipo ${\displaystyle (S\rightarrow T)\times S}$, donde S es el tipo base de la tienda. Las opreaciones de la co-mónada son:

${\displaystyle {\text{extract}}:((S\rightarrow T)\times S)\rightarrow T=(f,s)\mapsto f\,s}$

${\displaystyle {\text{extend}}:(((S\rightarrow A)\times S)\rightarrow B)\rightarrow ((S\rightarrow A)\times S)\rightarrow (S\rightarrow B)\times S\,}$${\displaystyle =f\mapsto (g,s)\mapsto ((s'\mapsto f\,(g,s')),s)}$

${\displaystyle {\text{fmap}}:(A\rightarrow B)\rightarrow ((S\rightarrow A)\times S)\rightarrow (S\rightarrow B)\times S=f\mapsto (f',s)\mapsto (f\circ f',s)}$

${\displaystyle {\text{duplicate}}:((S\rightarrow A)\times S)\rightarrow (S\rightarrow ((S\rightarrow A)\times S))\times S=(f,s)\mapsto ((s'\mapsto (f,s')),s)}$

• Monad Tutorials Timeline Probably the most comprehensive collection of links to monad tutorials, ordered by date.
• Piponi, Dan (7 de agosto de 2006). «You Could Have Invented Monads! (And Maybe You Already Have.)». A Neighborhood of Infinity. — The most famous "blog post" tutorial.
• Yorgey, Brent (12 de marzo de 2009). «The Typeclassopedia». The Monad.Reader (13): 17-68. — An attempt to explain all of the leading typeclasses in Haskell in an elementary way, with monadic functors considered as only one form, best understood by comparison with others: e.g., the more general idea of a "Functor" as something you can map over; "Applicative" functors, and so forth; contains an extensive bibliography.
• Yorgey, Brent (12 de enero de 2009). «Abstraction, intuition, and the "monad tutorial fallacy"». blog :: Brent -> [String]. WordPress.com. — Opposes the idea of making a tutorial about monads in particular.
• What a Monad is not deals with common misconceptions and oversimplifications in a humorous way.
• beelsebob (31 de marzo de 2009). «How you should(n’t) use Monad». No Ordering. WordPress.com. — Takes a similar point of view, locating monads in a much wider array of Haskell functor classes, of use only in special circumstances.
• Vanier, Mike (25 de julio de 2010). «Yet Another Monad Tutorial (part 1: basics)». Mike's World-O-Programming. LiveJournal. — An extremely detailed set of tutorials, deriving monads from first principles.
• «A Fistful of Monads». An explanation of Monads, building on the concepts of Functors, Applicative Functors and Monoids discussed in the previous chapter.
• Functors, Applicatives and Monads in Pictures. A humorous beginner's guide to monads.

• All About Monads
• Haskell Wiki: Monads as Computation
• Haskell Wiki: Monads as Containers
• Norvell, Theodore. «Monads for the Working Haskell Programmer». Memorial University of Newfoundland.
• Klinger, Stefan (15 de diciembre de 2005). The Haskell Programmer’s Guide to the IO Monad — Don’t Panic (5–54). Centre for Telematics and Information Technology, University of Twente. ISSN 1381-3625. Archivado desde el original el 24 de marzo de 2015. Consultado el 30 de junio de 2014.
• Turoff, Adam (2 de agosto de 2007). «Introduction to Haskell, Part 3: Monads». ONLamp. O'Reilly Media. Archivado desde el original el 1 de diciembre de 2017. Consultado el 30 de junio de 2014.
• Monads A monad tutorial providing examples of non-trivial monads apart from the conventional IO/Maybe/List/State monads.
• Söylemez, Ertugrul (11 de julio de 2010). «Understanding Haskell Monads».

• van Tuyl, Henk-Jan (27 de febrero de 2010). «A tour of the Haskell monad functions».
• Moggi, Eugenio. Notions of computation and monads. — el paper original donde se sugiere el uso de mónadas para programación
• Wadler, Philip (agosto de 2001). Monads for functional programming. Universidad de Glasgow. — describe mónadas en Haskell (antes de que se implementaran)

• League, Chris (12 de julio de 2010). Monadologie: Professional Help for Type Anxiety (flv) (Tech talk). Nueva York: New York Scala Enthusiasts.
• Morris, Tony (22 de junio de 2010). «Understanding Monads using Scala (Part 1)». λ Tony’s blog λ.
• Iry, James (18 de septiembre de 2007). «Monads are Elephants».
• Meredith, Gregory (25 de abril de 2010). «Pro Scala: Monadic Design Patterns for the Web» (1st edición). p. 300.

• Monads in Perl
• Monads in Ruby
• Monads in Python
• Monads in Scala
• Monads in Clojure
• Monads in JavaScript
• Introduction to monads in C# and LINQ
• Library of monads for C#
• Monads in Ocaml
• Monads in PHP