Scala中使用Future、List和Option的for推导式

Question

我正在使用Scala和Play框架构建响应式网站，我的数据模型常常需要组合Future和Option，并从先前的值构建List/Set的Future以获取所需的结果。

我编写了一个简单的应用程序，使用虚拟数据源，您可以复制并粘贴它，然后应该能够编译。我的问题是，如何以可消耗的形式获取返回结果，即我的UserContext。目前，我得到的是Future[Option[Future[UserContext]]]。

我想要在纯Scala中做到这一点，以更好地学习该语言，因此我目前避免使用Scalaz。尽管我知道最终应该使用它。

package futures

import scala.concurrent.{Future, ExecutionContext}

// http://www.edofic.com/posts/2014-03-07-practical-future-option.html
case class FutureO[+A](future: Future[Option[A]]) extends AnyVal {

  def flatMap[B](f: A => FutureO[B])(implicit ec: ExecutionContext): FutureO[B] = {
    FutureO {
      future.flatMap { optA =>
        optA.map { a =>
          f(a).future
        } getOrElse Future.successful(None)
      }
    }
  }

  def map[B](f: A => B)(implicit ec: ExecutionContext): FutureO[B] = {
    FutureO(future.map(_ map f))
  }
}

// ========== USAGE OF FutureO BELOW ============= \\

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

object TeamDB {

  val basketballTeam = Team(id = 111, player_ids = Set(111, 222))
  val baseballTeam = Team(id = 222, player_ids = Set(333))

  def findById(teamId: Int): Future[Option[Team]] = Future.successful(
    teamId match {
      case 111 => Some(basketballTeam)
      case 222 => Some(baseballTeam)
      case _ => None
    }
  )
}

object PlayerDB {

  val basketballPlayer1 = Player(id = 111, jerseyNumber = 23)
  val basketballPlayer2 = Player(id = 222, jerseyNumber = 45)
  val baseballPlayer = Player(id = 333, jerseyNumber = 5)

  def findById(playerId: Int): Future[Option[Player]] = Future.successful(
    playerId match {
      case 111 => Some(basketballPlayer1)
      case 222 => Some(basketballPlayer2)
      case 333 => Some(baseballPlayer)
      case _ => None
    }
  )
}

object UserDB {

  // user1 is on BOTH the baseball and basketball team
  val user1 = User(id = 111, name = "Michael Jordan", player_ids = Set(111, 333), team_ids = Set(111, 222))

  // user2 is ONLY on the basketball team
  val user2 = User(id = 222, name = "David Wright", player_ids = Set(222), team_ids = Set(111))

  def findById(userId: Long): Future[Option[User]] = Future.successful(
    userId match {
      case 111 => Some(user1)
      case 222 => Some(user2)
      case _ => None
    }
  )
}

case class User(id: Int, name: String, player_ids: Set[Int], team_ids: Set[Int])
case class Player(id: Int, jerseyNumber: Int)
case class Team(id: Int, player_ids: Set[Int])
case class UserContext(user: User, teams: Set[Team], players: Set[Player])

object FutureOptionListTest extends App {

  val result = for {
    user <- FutureO(UserDB.findById(userId = 111))

  } yield for {
      players: Set[Option[Player]] <- Future.traverse(user.player_ids)(x => PlayerDB.findById(x))
      teams: Set[Option[Team]] <- Future.traverse(user.team_ids)(x => TeamDB.findById(x))

    } yield {
        UserContext(user, teams.flatten, players.flatten)

      }

  result.future // returns Future[Option[Future[UserContext]]] but I just want Future[UserContext] or UserContext
}

- sanchezjjose

---

我不确定你是否需要嵌套的yield。 - JoseM

Answer 1

你已经创建了FutureO，它结合了Future和Option的效果（如果你正在研究Scalaz，这与OptionT [Future，？]相比较）。

记住for ... yield类似于FutureO.map，结果类型将始终为FutureO [?]（如果你执行result.future，则为Future [Option [?]]）。

问题在于你想返回Future [UserContex]而不是Future [Option [UserContext]]。本质上，你希望失去Option上下文，因此你需要在某个地方明确处理用户是否存在。

在这种情况下，一个可能的解决方案是省略FutureO，因为你只使用它一次。

case class NoUserFoundException(id: Long) extends Exception 

// for comprehension with Future
val result = for {
  user <- UserDB.findById(userId = 111) flatMap (
            // handle Option (Future[Option[User]] => Future[User])
            _.map(user => Future.successful(user))
             .getOrElse(Future.failed(NoUserFoundException(111)))
          )
  players <- Future.traverse(user.player_ids)(x => PlayerDB.findById(x))
  teams  <- Future.traverse(user.team_ids)(x => TeamDB.findById(x))
} yield UserContext(user, teams.flatten, players.flatten)
// result: scala.concurrent.Future[UserContext]

如果您有多个返回Future[Option[?]]的函数，您可能希望使用FutureO，在这种情况下，您可以创建一个额外的函数Future[A] => FutureO[A]，这样您就可以在同一for组合中使用您的函数（都在FutureO单子中）：

def liftFO[A](fut: Future[A]) = FutureO(fut.map(Some(_)))

// for comprehension with FutureO
val futureO = for {
  user <- FutureO(UserDB.findById(userId = 111))
  players <- liftFO(Future.traverse(user.player_ids)(x => PlayerDB.findById(x)))
  teams  <- liftFO(Future.traverse(user.team_ids)(x => TeamDB.findById(x)))
} yield UserContext(user, teams.flatten, players.flatten)
// futureO: FutureO[UserContext]

val result = futureO.future flatMap (
   // handle Option (Future[Option[UserContext]] => Future[UserContext])
   _.map(user => Future.successful(user))
    .getOrElse(Future.failed(new RuntimeException("Could not find UserContext")))
)
// result: scala.concurrent.Future[UserContext]

但是正如您所看到的，您总是需要在返回 Future[UserContext] 之前处理“选项上下文”。

- Peter Neyens

---

谢谢Peter！我喜欢将所有内容规范化为FutureO的第二种方法。实际上，我有更多涉及多个FutureO的用例，所以这个解决方案非常完美。感谢您提前考虑并建议这个方法！ - sanchezjjose

Answer 2

为了进一步解释Peter Neyens的答案，我通常会将一堆单子变换放在一个特殊的隐式类中，并在需要时导入它们。这里有两个单子，Option[T]和Future[T]。在这种情况下，你把None视为失败的Future。你可能可以这样做：

package foo {
    class OptionOps[T](in: Option[T]) {
        def toFuture: Future[T] = in match {
            case Some(t) => Future.successful(t)
            case None => Future.failed(new Exception("option was none"))
        }
    }
    implicit def optionOps[T](in: Option[T]) = new OptionOps[T](in)
}

接着，你只需要导入它 import foo.optionOps

然后执行：

val a: Future[Any] = ...
val b: Option[Any] = Some("hi")
for {
    aFuture <- a
    bFuture <- b.toFuture
} yield bFuture // yields a successful future containing "hi"

- Daniel Fithian

---

太棒了，感谢你的建议Daniel！将单子变换隐式化并分组到一个类中是一个不错的改进。 - sanchezjjose

这里可能有语法错误吗？我有点困惑 implicit def optionOps[T]... 属于哪个作用域，以及它如何与 @peter-neyens 的答案相关联。抱歉，我是 Scala 新手。 - janakagamini

将foo.optionOps导入到一个包中，将会使得toFuture对任何Option[T]可见。b是Option[Any]，所以b.toFuture返回的是Future[Any]。这只是将Future[Option[Future[T]]]扁平化的另一种解决方案，通过将选项转换为未来。 - Daniel Fithian