scala - 为什么编译器会错误地推断函数中 Future.sequence 声明的返回类型？

Question

在 scala2 或 3 中这个函数编译:

def returnsFutureOfFutureButCompiles(): Future[Unit] = {  
  for {
    _ <- Future.unit
  } yield Future.sequence(Seq(Future.unit)) // Returns Future[Future[Seq[Unit]]]
}

但这个不是:

def returnsFutureOfFutureButDoesNotCompile(): Future[Unit] = {
  val a = for {
    _ <- Future.unit
  } yield Future.sequence(Seq(Future.unit))
  a // Error: Required: Future[Unit], Found: Future[Future[Seq[Unit]]]
}

I am aware of for-comprehension syntaxic sugar, differences between map and flatMap and how monads work.

编译器应该对这两个函数发出警告

我不理解这些不同的行为，因为这些函数几乎在做同样的工作。
也许这与类型推断限制有关，但为什么呢？

此外，如果我声明这些函数:

def a(): Future[Int] = {
  for {
    _ <- Future.successful(1)
  } yield Future.successful(2) // Error: Required: Int, Found: Future[Int]
}

def b(): Future[Int] = {
  val value = for {
    _ <- Future.successful(1)
  } yield Future.successful(2)
  value // Error: Required: Future[Int], Found: Future[Future[Int]]
}

然后编译器就这两个函数发出正确的警告，正如预期的那样。

所以，我认为问题可能与 Future.sequence 有关？

Answer 1

这与您专门使用Unit有关。

如你所知:

val a = for {
  _ <- Future.unit
} yield Future.sequence(Seq(Future.unit))

编译为:

Future.unit.map { _ =>
  Future.sequence(Seq(Future.unit))
}

它应该推断为 Future[Future[Seq[Unit]]]。但是当你告诉它结果应该是 Future[Unit] 时，编译器开始逆向工作，从它应该得到的类型，到它得到的类型。

因此它推断你想要:

Future.unit.map[Unit] { _ =>
  Future.sequence(Seq(Future.unit))
}

这是正确的，因为当返回的类型是 Unit 时，它可以将代码视为您编写的代码:

Future.unit.map[Unit] { _ =>
  Future.sequence(Seq(Future.unit))
  ()
}

然而，“删除非单位值”只有在整个推理同时发生时才会发生。当你这样做时:

val a = for {
  _ <- Future.unit
} yield Future.sequence(Seq(Future.unit))
a

你有两个语句/表达式，所以单个推理不能反向工作。现在不知道 val a 应该被限制为 Future[Unit] 类型，它将它推断为 Future[Future[Seq[Unit]]]。下一步，单独的步骤，尝试将它与 Future[Unit] 匹配并失败，因为现在更改先前语句的类型并修改 map 的主体以删除返回值为时已晚.

在 Scala 2 中，您可以使用 -Wvalue-discard 或 -Ywarn-value-discard 强制您手动插入 ()如果您想丢弃应返回 Unit 的正文中的非 Unit 值。 Scala 3 仍在等待获得这样的警告标志。