Utilisation de la monade Maybe "inversée"

Question

Disons que j'ai un certain nombre de fonctions:

f :: a -> Maybe a
g :: a -> Maybe a
h :: a -> Maybe a

Et je veux, pour composer de la façon suivante: Si f ne retourne Rien, calculer g. Si g ne retourne Rien, calculer h. Si l'un d'eux de calcul Juste, arrêter la chaîne. Et l'ensemble de la composition (h . g . f) ne doivent évidemment de retour Peut-être un.

C'est l'inverse de l'utilisation classique de la monade Peut-être, où, en principe, vous arrêtez de calcul, si Rien n'est retourné.

Quel est le langage Haskell pour le chaînage des calculs de ce genre?

Answer 1

mplus est exactement ce que vous recherchez, qui fait partie de la classe de types MonadPlus . Voici sa définition:

 instance MonadPlus Maybe where
   mzero = Nothing

   Nothing `mplus` ys  = ys
   xs      `mplus` _ys = xs
 

Pour l'utiliser dans votre cas:

 combined x = (f x) `mplus` (g x) `mplus` (h x) 
 

Answer 2

mplus est probablement meilleur, mais cela devrait également fonctionner:

 import Data.List
import Data.Maybe 
import Control.Monad 

join $ find isJust [f x, g y, h z]
 

Answer 3

Je suppose que tu veux dire:

 f,g,h:: a -> Maybe b
 

Utiliser MonadPlus

 f x `mplus` g x `mplus` h x
 

Vous voudrez peut-être utiliser la State Monad:

 function = runReaderT $ ReaderT f `mplus` ReaderT g `mplus` ReaderT h
 

f, g, h are ReaderT a Peut-être b (jusqu’au ReaderT)

ou en utilisant msum:

 function = runReaderT $ msum $ map ReaderT [f,g,h]