Scala 期货使用 Future.sequence 但返回元组有问题

Question

I am having some trouble trying to return a tuple when I am using Future.sequence below:

type UserId = Int
  type GameId = Int
  type Score = Double

  case class Game(id: GameId)

  def findGame(id: GameId): Future[Game] = ???
  def findUserGames(id: UserId): Future[Seq[(GameId, Score)]] = ???

  def findGames(id: UserId): Future[Seq[(Game, Score)]] = {
    val userGames = findUserGames(id)

    // ******* I am stuck here
    val games: Future[Seq[Game]] = userGames.flatMap(x => Future.sequence(x.map(y => findGame(y._1))))    
  }

How can I return a tuple of (Game, Score) when the Future.sequence call is just returning me a Seq[Game] ?

Also, if we didn't have Future.sequence , how would we be able to mimic what it does? ie converting a List[Future[Game]] into a Future[List[Game]] ?

Answer 1

You can try this:

def findGames(id: UserId): Future[Seq[(Game, Score)]] = {
  findUserGames(id).flatMap(gameIdToScoreSeq =>
    Future.traverse(gameIdToScoreSeq)(gameIdToScore =>
      findGame(gameIdToScore._1).map((_, gameIdToScore._2))
    )
  )
}

Answer 2

just by keeping track of what is what by name, as a oneliner, you can do

def findGames(id: UserId)(implicit ec: ExecutionContext): Future[Seq[(Game, Score)]] =
  findUserGames(id).flatMap(games =>
    Future.sequence(games.map { case (gameid, score) =>
      findGame(gameid).map(game => game -> score)
    })
  )

Answer 3

You just need one more map:

val games: Future[Seq[(Game, Score)]] = userGames.flatMap(x => Future.sequence(x.map(y => findGame(y._1).map(z => (z, y._2)))))

As you can see it's getting a little bit convoluted. You could make your code more readable (arguably) by using for-comprehensions and pattern matching:

val games2: Future[Seq[(Game, Score)]] = for {
  games <- userGames
  result <- Future.sequence(games.map {
    case (gameId, score) => 
      for {
        game <- findGame(gameId)
      } yield (game, score)
  })
} yield result