CODEWITHSUNDEEP
haskellmonads
Ara Vartanian
Ara Vartanian

Reputation: 1563

Using the Maybe Monad in "reverse"

Let's say I have a number of functions:

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

And I want to compose them in the following way: If f returns Nothing, compute g. If g returns Nothing, compute h. If any of them compute Just a, stop the chain. And the whole composition (h . g . f) should of course return Maybe a.

This is the reverse of the typical use of the Maybe monad, where typically you stop computing if Nothing is returned.

What's the Haskell idiom for chaining computations like this?

Upvotes: 40

Views: 2900

Answers (3)

Landei
Landei

Reputation: 54574

mplus is probably better, but this should work as well:

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

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

Upvotes: 4

ysdx
ysdx

Reputation: 9315

I guess you mean:

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

Using MonadPlus

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

You might want to use the StateT Monad:

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

f,g,h are ReaderT a Maybe b (up to the ReaderT)

or using msum:

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

Upvotes: 3

acfoltzer
acfoltzer

Reputation: 5608

mplus is exactly what you're looking for, part of the MonadPlus typeclass. Here's its definition:

instance MonadPlus Maybe where
   mzero = Nothing

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

To use it in your case:

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

Upvotes: 47

Related Questions