Esto está disponible aquí como a .archivo lhs.

El transformador MaybeT nos permitirá salir de un cálculo de mónada como lanzar una excepción.

Primero repasaré rápidamente algunos preliminares. Saltar hacia abajo a Añadiendo Tal vez poderes a IO para un ejemplo trabajado.

Primero algunas importaciones:

 import Control.Monad
 import Control.Monad.Trans
 import Control.Monad.Trans.Maybe

Reglas de oro:

En una pila de mónadas, IO siempre está en la parte inferior.

Otras mónadas similares a io también, como regla general, siempre aparecen en la parte inferior, por ejemplo, la mónada del transformador de estado ST.

MaybeT m es un nuevo tipo de mónada que añade la potencia de la mónada Maybe a la mónada m - por ejemplo, MaybeT IO.

Vamos a entrar en lo que ese poder es más tarde. Por ahora, acostúmbrate a pensar en MaybeT IO como la pila de mónadas maybe+IO.

Al igual que IO Int es una expresión de mónada que devuelve un Int, MaybeT IO Int es una expresión MaybeT IO que devuelve un Int.

Consiguiendo acostumbrado a leer las firmas de tipo compuesto es la mitad de la batalla para entender los transformadores de mónada.

Toda expresión en un bloque do debe ser de la misma mónada.

Esto funciona porque cada declaración está en la IO-mónada:

 greet :: IO ()                               -- type:
 greet = do putStr "What is your name? "      -- IO ()
            n <- getLine                      -- IO String
            putStrLn $ "Hello, " ++ n         -- IO ()

Esto no funcionará porque putStr no está en la MaybeT IO mónada:

mgreet :: MaybeT IO ()
mgreet = do putStr "What is your name? "    -- IO monad - need MaybeT IO here
            ...

Afortunadamente hay una manera de arreglar esto.

Para transformar una expresión IO en una expresión MaybeT IO use liftIO.

liftIO es polimórfico, pero en nuestro caso tiene el tipo:

liftIO :: IO a -> MaybeT IO a

 mgreet :: MaybeT IO ()                             -- types:
 mgreet = do liftIO $ putStr "What is your name? "  -- MaybeT IO ()
             n <- liftIO getLine                    -- MaybeT IO String
             liftIO $ putStrLn $ "Hello, " ++ n     -- MaybeT IO ()

Ahora toda la declaración en mgreet son de la MaybeT IO mónada.

Cada transformador de mónada tiene una función "run".

La función run "ejecuta" la capa superior de una pila de mónadas que devuelve un valor de la capa interior.

Para MaybeT IO, la función run es:

runMaybeT :: MaybeT IO a -> IO (Maybe a)

Ejemplo:

ghci> :t runMaybeT mgreet 
mgreet :: IO (Maybe ())

ghci> runMaybeT mgreet
What is your name? user5402
Hello, user5402
Just ()

También intente ejecutar:

runMaybeT (forever mgreet)

Necesita usar Ctrl-C para salir del bucle.

Hasta ahora mgreet no hace nada más que lo que podríamos hacer en IO. Ahora trabajaremos en un ejemplo que demuestra el poder de mezclar la Tal Vez mónada con IO.

Añadiendo tal vez poderes a IO

Comenzaremos con un programa que hace algunas preguntas: {[62]]}

 askfor :: String -> IO String
 askfor prompt = do
   putStr $ "What is your " ++ prompt ++ "? "
   getLine

 survey :: IO (String,String)
 survey = do n <- askfor "name"
             c <- askfor "favorite color"
             return (n,c)

Ahora supongamos que queremos darle al usuario la capacidad de finalizar la encuesta temprano escribiendo FIN en respuesta a una pregunta. Podríamos manejarlo este camino:

 askfor1 :: String -> IO (Maybe String)
 askfor1 prompt = do
   putStr $ "What is your " ++ prompt ++ " (type END to quit)? "
   r <- getLine
   if r == "END"
     then return Nothing
     else return (Just r)

 survey1 :: IO (Maybe (String, String))
 survey1 = do
   ma <- askfor1 "name"
   case ma of
     Nothing -> return Nothing
     Just n  -> do mc <- askfor1 "favorite color"
                   case mc of
                     Nothing -> return Nothing
                     Just c  -> return (Just (n,c))

El problema es que survey1 tiene el problema familiar de escalonamiento que no se escala si añadimos más preguntas.

Podemos usar el transformador MaybeT monad para ayudarnos aquí.

 askfor2 :: String -> MaybeT IO String
 askfor2 prompt = do
   liftIO $ putStr $ "What is your " ++ prompt ++ " (type END to quit)? "
   r <- liftIO getLine
   if r == "END"
     then MaybeT (return Nothing)    -- has type: MaybeT IO String
     else MaybeT (return (Just r))   -- has type: MaybeT IO String

Observe cómo todos los statemens en askfor2 tienen el mismo tipo de mónada.

Hemos usado una nueva función:

MaybeT :: IO (Maybe a) -> MaybeT IO a

Así es como funcionan los tipos:

                  Nothing     :: Maybe String
           return Nothing     :: IO (Maybe String)
   MaybeT (return Nothing)    :: MaybeT IO String

                 Just "foo"   :: Maybe String
         return (Just "foo")  :: IO (Maybe String)
 MaybeT (return (Just "foo")) :: MaybeT IO String

Aquí return es de la IO-mónada.

Ahora podemos escribir nuestra función de encuesta como esto:

 survey2 :: IO (Maybe (String,String))
 survey2 =
   runMaybeT $ do a <- askfor2 "name"
                  b <- askfor2 "favorite color"
                  return (a,b)

Intente ejecutar survey2 y terminar las preguntas antes escribiendo END como respuesta a cualquiera de las preguntas.

Atajos

Sé que recibiré comentarios de la gente si no menciono los siguientes atajos.

La expresión:

MaybeT (return (Just r))    -- return is from the IO monad

También se puede escribir simplemente como:

return r                    -- return is from the MaybeT IO monad

También, otra forma de escribir MaybeT (return Nothing) es:

mzero

Además, dos declaraciones liftIO consecutivas siempre pueden combinarse en una sola {[38]]}, por ejemplo:

do liftIO $ statement1
   liftIO $ statement2 

Es lo mismo que:

liftIO $ do statement1
            statement2

Con estos cambios nuestra función askfor2 puede escribirse:

askfor2 prompt = do
  r <- liftIO $ do
         putStr $ "What is your " ++ prompt ++ " (type END to quit)?"
         getLine
  if r == "END"
    then mzero      -- break out of the monad
    else return r   -- continue, returning r

En cierto sentido, mzero se convierte en una forma de salir de la mónada - como lanzar una excepción.

Otro ejemplo

Considere este sencillo bucle de pregunta de contraseña:

loop1 = do putStr "Password:"
           p <- getLine
           if p == "SECRET"
             then return ()
             else loop1

Esta es una función recursiva (cola) y funciona muy bien.

En un lenguaje convencional podríamos escribir esto como un bucle while infinito con una ruptura declaración:

def loop():
    while True:
        p = raw_prompt("Password: ")
        if p == "SECRET":
            break

Con MaybeT podemos escribir el bucle de la misma manera que el código Python:

loop2 :: IO (Maybe ())
loop2 = runMaybeT $
          forever $
            do liftIO $ putStr "Password: "
               p <- liftIO $ getLine
               if p == "SECRET"
                 then mzero           -- break out of the loop
                 else return ()

El último return () continúa la ejecución, y como estamos en un bucle forever, control vuelve a la parte superior del bloque do. Tenga en cuenta que el único valor que loop2 puede devolver es Nothing que corresponde a la ruptura del bucle.

Dependiendo de la situación, puede que le resulte más fácil escribir loop2 en lugar de la recursiva loop1.