El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Mónadas

Siguiente ►
►

Las mónadas son un concepto fundamental en Haskell y en la programación funcional en general. Aunque pueden parecer complicadas al principio, son una herramienta poderosa para manejar efectos secundarios, como la entrada/salida, el manejo de errores y el estado mutable, de una manera pura y funcional.

¿Qué es una Mónada?

Una mónada es una estructura que representa cálculos secuenciales. En Haskell, una mónada es un tipo que implementa las siguientes tres operaciones:

  1. return: Toma un valor y lo coloca en un contexto monádico.
  2. >>= (bind): Toma un valor en un contexto monádico y una función que produce un nuevo contexto monádico, y los combina.
  3. >>: Similar a >>=, pero ignora el valor producido por el primer cálculo.

Definición de la Clase Monad

En Haskell, la clase Monad se define de la siguiente manera:

class Applicative m => Monad m where
    return :: a -> m a
    (>>=)  :: m a -> (a -> m b) -> m b
    (>>)   :: m a -> m b -> m b
    m >> k = m >>= \_ -> k

Ejemplo: La Mónada Maybe

La mónada Maybe es una de las más simples y se utiliza para representar cálculos que pueden fallar. La definición de Maybe es la siguiente:

data Maybe a = Nothing | Just a

La instancia de Monad para Maybe se define así:

instance Monad Maybe where
    return = Just

    Nothing >>= _ = Nothing
    Just x  >>= f = f x

Ejemplo Práctico

Supongamos que tenemos dos funciones que pueden fallar:

safeDiv :: Int -> Int -> Maybe Int
safeDiv _ 0 = Nothing
safeDiv x y = Just (x `div` y)

safeSqrt :: Int -> Maybe Int
safeSqrt x
    | x < 0     = Nothing
    | otherwise = Just (floor . sqrt . fromIntegral $ x)

Podemos componer estas funciones usando la notación do:

safeDivSqrt :: Int -> Int -> Maybe Int
safeDivSqrt x y = do
    z <- safeDiv x y
    safeSqrt z

Ejercicio Práctico

Ejercicio 1: Implementar una Mónada Simple

Implementa una mónada Logger que registre mensajes durante el cálculo.

data Logger a = Logger [String] a deriving Show

instance Monad Logger where
    return x = Logger [] x
    (Logger logs x) >>= f = 
        let Logger newLogs y = f x
        in Logger (logs ++ newLogs) y

logMsg :: String -> Logger ()
logMsg msg = Logger [msg] ()

example :: Logger Int
example = do
    logMsg "Starting calculation"
    x <- return 42
    logMsg "Calculation done"
    return x

Solución:

data Logger a = Logger [String] a deriving Show

instance Monad Logger where
    return x = Logger [] x
    (Logger logs x) >>= f = 
        let Logger newLogs y = f x
        in Logger (logs ++ newLogs) y

logMsg :: String -> Logger ()
logMsg msg = Logger [msg] ()

example :: Logger Int
example = do
    logMsg "Starting calculation"
    x <- return 42
    logMsg "Calculation done"
    return x

-- Ejecución del ejemplo
-- > example
-- Logger ["Starting calculation","Calculation done"] 42

Errores Comunes y Consejos

  1. Olvidar el Contexto Monádico: Asegúrate de que todas las funciones que uses dentro de una mónada devuelvan un valor en el contexto monádico.
  2. Confundir >> y >>=: Usa >> cuando no te importe el valor producido por el primer cálculo, y >>= cuando necesites pasar ese valor a la siguiente función.
  3. No Usar do Notation: La notación do puede hacer que el código sea más legible y fácil de seguir.

Conclusión

Las mónadas son una herramienta poderosa en Haskell para manejar cálculos secuenciales y efectos secundarios de manera pura. Aunque pueden parecer complicadas al principio, con práctica y ejemplos prácticos, se vuelven una parte esencial del arsenal de cualquier programador funcional. En el próximo tema, exploraremos los funtores aplicativos, que son una generalización de las mónadas y proporcionan aún más flexibilidad en la programación funcional.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados