Calculate module of "Just int" in Haskell

You can do this with fmap :: Functor f => (a -> b) -> f a -> f b or its operator variant (<$>) :: Functor f => (a -> b) -> f a -> f b to apply a function to the item wrapped in the Just … data constructor:

b = (`mod` 2) <$> a

this will then return Just 0 when a is Just 2, and Nothing if the elemIndex returned a Nothing. This thus means that if elemIndex fails (because the index is out of range), b will be Nothing.

You can just use pattern matching with let to get to the inner part of the Maybe value when it is guaranteed to be Just _:

list = [5,6,7,8]
a = elemIndex 7 list
b = mod a 2

foo list = [b | n <- [5,6,7,8]
              , let a = elemIndex n [5,6,7,8]
              , let Just i = a
              , let b = mod i 2]
         = [b | n <- list
              , let Just i = elemIndex n list
              , let b = mod i 2]
         = [b | (_, i) <- zip list [0..]
              , let b = mod a 2]
         = ls where ls = [0,1] ++ ls

bar list = [(n,b) | n <- list
                  , let Just i = elemIndex n list
                  , let b = mod i 2]
         = [(n,b) | (n, i) <- zip list [0..]
                  , let b = mod i 2]
         = zip list ls where ls = cycle [0,1]

Normally this kind of pattern matching is frowned upon since it is partial, i.e. can cause error if the value is actually Nothing, but here it is correct by construction.

But then really, why put it into a Just -- just use it as it is. And we did.