Refactoring “staircasing” with case of `Maybe` values in `IO` code

Question

The following function f attempts to read an Int twice by using an IO (Maybe Int) function twice, but “short-circuits” execution after successfully reading one Int:

readInt :: IO (Maybe Int)

f :: IO (Maybe Int)
f = do
  n1 <- readInt
  case n1 of
      Just n' -> return (Just n')
      Nothing -> do
        n2 <- readInt
        case n2 of
              Just n' -> return (Just n')
              Nothing -> return Nothing

Is there a good way to refactor this code? This would get very hairy if I extended it to three attempts…

(My thought process: Seeing this “staircasing” tells me that maybe I should be using the Monad instance of Maybe, but since this is already in the IO monad, I would then have to use MaybeT(?). However, I only need one of the readInt to succeed, so the Maybe monad's behaviour of erroring out on the first Nothing would be wrong here...)

score 8 · Accepted Answer · edited Jan 24 '15 at 16:16

8

You can use MaybeT and the MonadPlus instance to use msum:

f :: MaybeT IO Int
f = msum [readInt, readInt, readInt]

edited Jan 24 '15 at 16:16

Cactus

27,075
9
69
149

answered Jan 24 '15 at 11:22

Lee

142,018
20
234
287

Perhaps clarify for the benefit of others that he'd have to wrap the `IO (Maybe Int)` computation in the `MaybeT` constructor – Gabriella Gonzalez Jan 24 '15 at 15:07

score 4 · Answer 2 · answered Jan 24 '15 at 11:28

You need the alternative instance for MaybeT:

instance (Functor m, Monad m) => Alternative (MaybeT m) where
    empty = mzero
    (<|>) = mplus

instance (Monad m) => MonadPlus (MaybeT m) where
    mzero = MaybeT (return Nothing)
    mplus x y = MaybeT $ do
        v <- runMaybeT x
        case v of
            Nothing -> runMaybeT y
            Just _  -> return v

I.e. compute the first argument and return the value if it's Just, otherwise compute the second argument and return the value.

The code:

import Control.Applicative
import Control.Monad
import Control.Monad.Trans.Maybe
import Text.Read

readInt :: MaybeT IO Int
readInt = MaybeT $ readMaybe <$> getLine 

main = runMaybeT (readInt <|> readInt) >>= print

score 1 · Answer 3 · answered Jan 24 '15 at 11:22

First of all,

n2 <- readInt
case n2 of
      Just n' -> return (Just n')
      Nothing -> return Nothing

is really just readInt. You are picking apart a Maybe value in order to put together the same one.

For the rest, I think the most succinct way in this case is to use the maybe function. Then you can get just

f = maybe readInt (return . Just) =<< readInt

score 1 · Answer 4 · answered Jan 24 '15 at 12:12

Another way of doing this is with the iterative monad transformer from the free package.

import Control.Monad.Trans.Iter (untilJust,retract,cutoff,IterT)

readInt :: IO (Maybe Int)
readInt = undefined

f' :: IterT IO Int
f' = untilJust readInt

f :: IO (Maybe Int)
f = (retract . cutoff 2) f'

Where cutoff specifies the maximum number of retries.

The advantage of this approach is that you can easily interleave other repeated actions with f', thanks to the MonadPlus instance of IterT. Logging actions for example, or wait actions.

Refactoring “staircasing” with case of `Maybe` values in `IO` code

4 Answers4