Scala用于理解Future,List和Option

Question

我在斯卡拉建设一个活性位点和播放框架,以及我的数据模型是这样的,我经常需要编写Future和Option,并建立Future的List/ Set以前的值以得到结果,我所需要的.

我写了一个带有假数据源的简单应用程序,你可以复制和粘贴它,它应该编译.我的问题是,在我的情况下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
}

Answer 1

你已经创建FutureO了结合了Future和的效果Option(如果你正在研究与之比较的Scalaz OptionT[Future, ?]).

记住这for ... yield类似于FutureO.map,结果类型将始终是FutureO[?](Future[Option[?]]如果你这样做result.future).

问题是你要返回一个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].