Ceci est disponible ici en tant que .fichier lhs.

Le transformateur MaybeT nous permettra de sortir d'un calcul de monade un peu comme lancer une exception.

Je vais d'abord passer rapidement en revue quelques préliminaires. Passez à en ajoutant peut-être des pouvoirs à IO pour un exemple travaillé.

D'abord quelques importations:

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

Règles de base:

Dans une pile de monades, IO est toujours en bas.

Les autres monades de type IO, en règle générale, apparaissent toujours sur le fond, par exemple le transformateur d'état monad ST.

MaybeT m est un nouveau type de monade qui ajoute la puissance de la Monade Maybe à la monade m - par exemple MaybeT IO.

Nous allons entrer dans ce que ce pouvoir est plus tard. Pour l'instant, habituez-vous à penser à MaybeT IO comme la pile de monades maybe+IO.

Comme IO Int est une monade expression retournant une Int, MaybeT IO Int est un MaybeT IO expression retournant une Int.

Obtenir utilisé pour lire les signatures de type composé est la moitié de la bataille pour comprendre les transformateurs de monade.

Chaque expression d'un bloc do doit provenir de la même monade.

C'est-à-dire que cela fonctionne parce que chaque instruction est dans la monade IO:

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

Cela ne fonctionnera pas car putStr n'est pas dans le MaybeT IO monade:

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

Heureusement, il y a un moyen de résoudre ce problème.

Pour transformer une expression IO en une expression MaybeT IO, utilisez liftIO.

liftIO est polymorphe, mais dans notre cas il a le type:

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 ()

Maintenant, toutes les instructions de {[40] } proviennent de la monade MaybeT IO.

Chaque transformateur monade a une fonction "run".

La fonction run "exécute" la couche la plus haute d'une pile de monades renvoyant une valeur du calque intérieur.

Pour MaybeT IO, la fonction d'exécution est:

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

Exemple:

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

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

Essayez aussi d'exécuter:

runMaybeT (forever mgreet)

Vous besoin d'utiliser Ctrl-C pour sortir de la boucle.

Jusqu'à présent mgreet ne fait rien de plus que ce que nous pourrions faire dans IO. Maintenant nous allons travailler sur un exemple qui démontre la puissance du mélange la Monade peut-être avec IO.

Ajouter peut-être des pouvoirs à IO

Nous allons commencer par un programme qui pose quelques questions:

 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)

Maintenant, supposons que nous voulons donner à l'utilisateur la possibilité de mettre fin à l'enquête tôt en tapant fin en réponse à une question. On peut le manipuler ce façon:

 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))

Le problème est que survey1 a le problème d'escalier familier qui ne change pas si nous ajoutons plus de questions.

Nous pouvons utiliser le transformateur MaybeT monad pour nous aider ici.

 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

Notez comment tous les statemens dans askfor2 ont le même type de monade.

, Nous avons utilisé une nouvelle fonction:

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

Voici comment les types fonctionnent:

                  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

Ici return provient de la Io-monade.

Maintenant, nous pouvons écrire notre fonction de sondage comme ce:

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

Essayez d'exécuter survey2 et de terminer les questions tôt en tapant fin comme réponse à l'une ou l'autre question.

Raccourcis

Je sais que je vais obtenir des commentaires des gens si Je ne mentionne pas les raccourcis suivants.

L'expression:

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

Peut aussi être écrit simplement comme:

return r                    -- return is from the MaybeT IO monad

Aussi, une autre manière d'écrire MaybeT (return Nothing) est:

mzero

De plus, deux instructions liftIO consécutives peuvent toujours être combinées en une seule liftIO, par exemple:

do liftIO $ statement1
   liftIO $ statement2 

Est le même que:

liftIO $ do statement1
            statement2

Avec ces changements, notre fonction askfor2 peut être écrite:

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

Dans un sens, mzero devient un moyen de sortir de la monade - comme lancer une exception.

Un autre exemple

Considérez cette simple boucle de demande de mot de passe:

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

C'est une fonction récursive (queue) et fonctionne très bien.

Dans un langage conventionnel, nous pourrions écrire ceci comme une boucle while infinie avec une pause déclaration:

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

Avec MaybeT nous pouvons écrire la boucle de la même manière que le code 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 ()

Le Dernier return () continue l'exécution, et puisque nous sommes dans une boucle forever, le contrôle revient en haut du bloc do. Notez que la seule valeur que loop2 peut renvoyer est Nothing ce qui correspond à la sortie de la boucle.

Selon la situation, vous pourriez trouver plus facile d'écrire loop2 plutôt que le récursif loop1.