用惯用的方式链接期货和期权

Question

def foo(user, id): Future[Option[Bar]] =
  bar(user, id).map(_.map(_.address.flatMap(_.street)))
    .flatMap {
      case Some(street) =>
        baz(user, street).flatMap(_ => get(id))
      case None => successful(None)
    }

Function bar returns an Option[UserInfo] , which I then map to a UserInfo . Address is also an Option so I flatMap that to have access to street . Then simply if there exists a street I want to call baz , if not then None . Ignore the business logic, it's made up for the example.

There's a problem with the code here as it won't compile.

Some(street) is an Option , since the flatMap on line 3 is being called on the result of the mapping on the first _ , instead of _.address .

Whilst I could get this to work with some parenthesis juggling and so on, this code is starting to get hard to read and reason about.

Are for-comprehensions the answer?

PS: There might be some type-information missing in this example so please ask and I will elaborate.

EDIT:

case class UserInfo(id: UserId, address: Option[Address])

case class Address(street: Option[List[Street]], state: Option[State])

Answer 1

If I understood method signatures right:

 def bar(user, id): Option[UserInfo]
 def baz(user, List[Street]): Future[BarId]
 def get(id): Option[Bar]

You can implement your method something like this:

val streetsOpt: Option[List[Street]] = bar(user, id).flatMap(_.flatMap(_.address.flatMap(_.street)))

streetsOpt.flatMap(streets => {
    baz(user, streets).map(_ => get(id))
}).getOrElse(successful(None)))

Answer 2

Just quickly looking at this, within this line:

baz(user, street).flatMap(_ => get(id))

I don't think that the last flatMap won't work properly because you seem to be passing in a function which is of a type something like:

f: => A

ie extracting the underlying value from some context, whereas flatMap expects you to unpack this value and then wrap in a new context, and so has type:

f: A => M[B]

When you are making the call to

get(id)

Shouldn't this be being applied to a map method instead, which expects a function of type:

f: A => B

Answer 3

There are a couple of ways of dealing with nested contexts like this. I gave a talk about three that I know: monad transformers (explicit, more "standard", but a bit more verbose), Kleisli (very elegant, if you're willing to write in pointfree style), or my scalaz-transfigure library (a bit immature, a bit less explicit, but very concise).