为scala过滤两个未来[Seq]

我有一些函数返回具有future的元组元素列表（Int，Int）。为了简单起见，我将定义两个未来

  val f1 = Future {
    List((8, 3), (2, 1), (4, 2), (3, 4))
  }
  val f2 = Future {
    List((2, 3), (5, 1), (7, 9))
  }

我想用以下标准筛选并获取这两个未来列表中的元素

在第二个位置包含相同元素的元组

在这个场景中，输出应该是

List(((2,1),(5,1)), ((8,3),(2,3))) 

我可以这样做与正常的名单（没有期货）与理解如下

val l1 = List((4, 2), (3, 4), (2, 1), (8, 3))
val l2 = List((2, 3), (5, 1), (7, 9))

val o = for {
  a <- l1
  b <- l2 if a._2 == b._2
} yield (a, b)

vall1=列表（（4,2）、（3,4）、（2,1）、（8,3））
val l2=列表（（2,3）、（5,1）、（7,9））
val o=用于{
如果您想使用full进行理解，请使用附加解决方案：

val o2 = for {
  l1 <- f1
  l2 <- f2
} yield for {
  a <- l1
  b <- l2 if a._2 == b._2
} yield (a,b)

val o2=用于{
l1如果您想使用“完整”进行理解，请使用其他解决方案：

val o2 = for {
  l1 <- f1
  l2 <- f2
} yield for {
  a <- l1
  b <- l2 if a._2 == b._2
} yield (a,b)

val o2=用于{
l1另一种可能性是scalaz（）中的
ListT
monad转换器：

导入scala.concurrent.ExecutionContext.Implicits.global
导入scala.concurrent.{wait，Future}
导入scalaz.scalaz_
进口scalaz_
导入scala.concurrent.duration_
def main（参数：数组[字符串]）：单位={
val f1=未来{
列表（（8,3）、（2,1）、（4,2）、（3,4））
}
val f2=未来{
列表（（2,3）、（5,1）、（7,9））
}
val first=ListT[未来，（整数，整数）]（f1）
val second=ListT[Future，（Int，Int）]（f2）
val res=用于{
另一种可能性是scalaz（）中的
ListT
monad转换器：

导入scala.concurrent.ExecutionContext.Implicits.global
导入scala.concurrent.{wait，Future}
导入scalaz.scalaz_
进口scalaz_
导入scala.concurrent.duration_
def main（参数：数组[字符串]）：单位={
val f1=未来{
列表（（8,3）、（2,1）、（4,2）、（3,4））
}
val f2=未来{
列表（（2,3）、（5,1）、（7,9））
}
val first=ListT[未来，（整数，整数）]（f1）
val second=ListT[Future，（Int，Int）]（f2）
val res=用于{
Scala 2.12在未来的
中添加了一个
zipWith
：

f1.zipWith(f2) {
  (l1, l2) => for {
    a <- l1
    b <- l2 if a._2 == b._2
  } yield (a, b)
}

f1.zipWith（f2）{
（l1，l2）=>对于{
Scala 2.12在未来的
中添加了一个
zipWith
：

f1.zipWith(f2) {
  (l1, l2) => for {
    a <- l1
    b <- l2 if a._2 == b._2
  } yield (a, b)
}

f1.zipWith（f2）{
（l1，l2）=>对于{
“用于压缩”？@pedrofurla编辑->理解“用于压缩”？@pedrofurla编辑->理解