Short-circuit AND within IO Monad

Question

I know the question has been asked there but I can't believe there is no straight answer.

I understand it's not good to hide side-effect inside a (&&) but in my case the side-effect are just checking something in the outstide world (existence of a file, check modification time etc, ask user a yes/no quistion).

So what is the haskell way to something like this, so that cond2 is not executed if cond1 is false.

cond1, cond2 :: IO bool


main = do
   cond <- liftM2 (&&) con1 con2
   if cond
   then   result1
   else   result2

I was expecting something like cond <- all [con1, con2] or equivalent, but I can't find anything.

Update

I can see lots of manual solution. I'm still puzzled that this function doesn't exists somewhere. One advantage of lazzy evaluation is it doesn't only short-circuit for hard-coded && like in C. It is really strange that when in imperative mode, Haskell can't even short-circuit &&. Although, all solution use somehow and if to short-circuit the evaluation. Is there not a way to make a generic lazzy liftM2 ?

Without using any special combinators: `andM [] = return True` and then `andM (x:xs) = do b <- x; if b then andM xs else return False` — ErikR, Nov 23 '14 at 18:47
As I said below, `andM` is defined in the monad-loops library, where one expects to find things like this http://hackage.haskell.org/package/monad-loops-0.4.2.1/docs/Control-Monad-Loops.html#v:andM — Michael, Nov 24 '14 at 16:51

score 8 · Answer 1 · answered Nov 23 '14 at 18:22

This is what Pipes.Prelude.and does, going over a lazy stream of effectfully-generated conditionals and short-circuiting if any of them are False:

import Pipes (each)
import qualified Pipes.Prelude as Pipes

conds :: [IO Bool]
conds = ...

main = do
    cond <- Pipes.and (each conds >-> Pipes.sequence)
    print cond

Relevant links:

Christian Conkle · Answer 2 · 2014-11-23T22:29:58.483

4

The operation you want is simple to define explicitly.

shortCircuitAnd :: Monad m => m Bool -> m Bool -> m Bool
shortCircuitAnd x y = do
   r1 <- x -- perform effect of x
   if r1 
     then y -- perform effect of y and return result
     else return False -- do *not* evaluate or perform effect of y

Of course, you can use this function infix as well, using backticks:

x `shortCircuitAnd` y == shortCircuitAnd x y

edited Nov 23 '14 at 22:29

answered Nov 23 '14 at 18:20

Christian Conkle

5,932
1
28
52

1

`r1 && r2` is actually `r2` since `r1` is guaranteed by the `if`. Hence, `do r1 <- x ; if r1 then y else return False` works. – chi Nov 23 '14 at 18:45

Michael · Accepted Answer · 2014-11-24T15:12:21.387

This isn't different from what some others are saying, but isn't it simplest just to emulate the definition of and:

 andM = foldr (&&&) (return True)
  where ma &&& mb = ma >>= \p -> if p then mb else return p

then we get, say:

 > let test1 = putStrLn "This test succeeds" >> return True
 > let test2 = putStrLn "This test fails" >> return  False
 > andM [test1,test2,undefined,undefined]
 This test succeeds
 This test fails
 False

If andM didn't 'short-circuit', then the undefined cell would have been evaluated and returned an exception.

It is a little irritating that liftM2 (&&) doesn't work as one hoped.

Edit: I just noticed that, as one might have expected, this is defined in the monad-loops package http://hackage.haskell.org/package/monad-loops-0.4.2.1/docs/src/Control-Monad-Loops.html#andM

danidiaz · Answer 4 · 2014-11-23T19:48:45.090

3

We can use a monad transformer like MaybeT, which is an instance of MonadPlus. The idea is to use guard to turn False results into mzeros that will halt the computation. And then we convert the resulting Maybe back into a Bool.

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

effyand :: (Functor m, Monad m) => [m Bool] -> m Bool
effyand = fmap isJust . runMaybeT . mapM_ (lift >=> guard)

edited Nov 23 '14 at 19:48

answered Nov 23 '14 at 18:54

danidiaz

26,936
4
45
95

1

I think it's better to add a little explanation to your answer rather than leave a block of code. – AdamMc331 Nov 23 '14 at 19:27

score 3 · Answer 5 · answered Nov 23 '14 at 21:23

I'd define a monoid like

newtype AllM m = AllM { getAllM :: m Bool }

instance (Monad m) => Monoid (AllM m) where
    mempty = AllM (return True)
    mappend (AllM u) (AllM v) = AllM $
        u >>= \x -> if x then v else return False

and then getAllM . mconcat . map AllM $ [con1, con2].

Short-circuit AND within IO Monad

Update

5 Answers5