5

I have written a program to pull a Maybe out of a pair:

deMaybe :: (a, Maybe b) -> Maybe (a, b)
deMaybe (_, Nothing) = Nothing
deMaybe (x,Just y) = Just (x, y)

I know that Maybe is a monad and (,) a is a functor (among other typeclasses). I'm wondering if there is a higher-level function I'm missing, such as:

commute :: (Functor f, Monad m) => f (m a) -> m (f a)

My question is: can I write deMaybe with a more general type signature like that of the hypothetical commute, acknowledging that I am trying to commute one functor past another? Can this be done using functions such as fmap, >>=, pure, &c.?

Phro
  • 375
  • 2
  • 11
  • 1
    You can work with `sequence` – Willem Van Onsem Apr 28 '22 at 20:29
  • In the general case, commutation is impossible: [this question](https://stackoverflow.com/questions/27267848/turning-a-mb-into-ma-b) focuses on the differences between `m (a->b)` and `a->m b`. Even if `(a->)` is a functor, and `m` is a monad, these do not commute in general. – chi Apr 28 '22 at 22:15

1 Answers1

7

You can work with sequence :: (Traversable t, Monad m) => t (m a) -> m (t a), but this requires a Traversable. For t ~ (b, ) and m ~ Maybe, this thus works as:

Prelude> sequence (2, Just 3)
Just (2,3)
Prelude> sequence (2, Nothing)
Nothing

A Traversable is a typeclass for data structures that can be transformed to an item with the same shape. We need this to construct thus a 2-tuple (or list, or something similar).

or we can use sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a) as @chepner says, which is more general since all Monads are also Applicatives:

Prelude> sequenceA (2, Just 3)
Just (2,3)
Prelude> sequenceA (2, Nothing)
Nothing
Willem Van Onsem
  • 443,496
  • 30
  • 428
  • 555
  • 4
    There's also `sequenceA`, as we only need `Maybe` to be an applicative functor, not necessarily a monad. – chepner Apr 28 '22 at 20:56