Is there a more idiomatic way of getting IO[Option[A]] from Option[IO[Option[A]] then using sequence and mapping join?

Question

I'm running into quite a few places where I have something akin to

def f(s: String): Option[Long] = ...
def g(l: Long): IO[Option[Wibble]] = ...

val a: IO[Option[Wibble]] = f(param).flatMap(g).sequence.map(_.join)

Seeing the .sequence.map(_.join) repeated over and over is starting to bother me. Is there a more idiomatic way of accomplishing the same thing?

Are you sure about the types in the example? g's type doesn't look compatible with flatMap there to me. — Kristian Domagala, Jan 12 '12 at 06:05
If I understand you correctly you want to do exactly that: http://stackoverflow.com/questions/5968345/un-optioning-an-optioned-option — Piotr Kukielka, Jan 12 '12 at 09:29

score 1 · Answer 1 · answered Apr 12 '12 at 06:26

The idiomatic method for dealing with Option chains is to use for-comprehensions and a getOrElse call.

val a = for {
    val temp <- f(param)
    val result <- Some(g(temp))
} yield result getOrElse <Default Here>

There's no getting around either having a default or raising an exception if you are going to categorically unpack the Option since f can return None and g can't accept that.

score 1 · Answer 2 · answered Jan 13 '12 at 12:16

1

This sounds like the use case for monad transformers, see here for an explanation in Haskell and here for a discussion in Scala.

answered Jan 13 '12 at 12:16

Ozymandias

521
2
16

Is there a more idiomatic way of getting IO[Option[A]] from Option[IO[Option[A]] then using sequence and mapping join?

2 Answers2