Scala类型推理规则对逆变？

Question

我在使用 Circe 并注意到一些我不太熟悉的东西，并想了解引擎盖下发生了什么？

从根本上说，这并不是一个真正的问题。我也只是在玩circe来测试一些东西。所以可以直接在JsonObject 中解码，但这不是重点。

val jobjectStr = """{
    |    "idProperty": 1991264,
    |    "nIndex": 0,
    |    "sPropertyValue": "0165-5728"
    |  }""".stripMargin



val jobject = decode[Json](jobjectStr).flatMap{ json =>
    json.as[JsonObject]
}

我的问题是关于 Either 的 flapMap 签名、逆变和这里发生的事情：

我们有以下几种：

decode[Json](jobjectStr): Either[Error, Json]

json.as[JsonObject]: Decoder.Result[JsonObject]

circe 定义的地方

final type Result[A] = Either[DecodingFailure, A]

和

sealed abstract class DecodingFailure(val message: String) extends Error {

现在 flatMap 的签名是：

def flatMap[A1 >: A, B1](f: B => Either[A1, B1]): Either[A1, B1]

换句话说，只谈论类型就像我的代码正在做的那样

Either[Error, Json] flatMap Either[DecodingFailure, JsonObject]

因此我的问题是： DecodingFailure >: Error 不是真的

确实，完整表达式的类型是：

decode[Json](jobjectStr).flatMap{ json =>
    json.as[JsonObject]
}: Either[Error, JsonObject]

因此我很困惑，因为我的理解是，Either 的第一个参数的类型在 flatMap 签名中是逆变的。这里似乎正在进行一些奇怪的最小上限推理......但我不确定为什么或是否是这种情况。

有什么解释吗？

Answer 1

这确实不是方差问题。 A1 >: A 只是告诉我们结果类型A1 可能必须是接收类型A 的超类型，如果编译器必须去寻找最小上限（LUB）。 （我认为在f: B => ... 描述中使用A1 有点令人困惑。）

考虑以下几点：

class Base
class SubA extends Base
class SubB extends Base

Either.cond(true, "a string", new SubA)
  .flatMap(Either.cond(true, _, new SubB))

//res0: scala.util.Either[Base,String] = Right(a string)

注意结果是Either[Base,String]，因为Base 是SubA 和SubB 的LUB。

Answer 2

所以首先，我们需要了解编译器总是会尝试推断允许编译的类型。避免编译某些东西的唯一真正方法是使用implicits。
（不确定这是语言规范的一部分，还是编译器实现细节，还是所有人都共有的东西编译器，或错误或功能）。

现在，让我们从一个更简单的示例 List 和 :: 开始。

sealed trait List[+A] {
  def ::[B >: A](b: B): List[B] = Cons(b, this)
}

final case class Cons[+A](head: A, tail: List[A]) extends List[A]
final case object Nil extends List[Nothing]

所以，假设编译器总是允许像x :: list 这样的代码总是编译。那么，我们有三个场景：

1. x 是 A 类型，list 是 List[A]，所以很明显返回值必须是 List[ A]。
2. x 是某种 C 类型，list 是 List[A]，C 是 A 的子类型 (C <: A)。然后，编译器简单地将 x 向上转换为 A 类型，然后继续执行前一个过程。
3. x 属于某种类型 D，list 是 List[A]，而 D 不是 的子类型一个。然后，编译器找到了一个新类型B，它是D和A之间的LUB，编译器最终将x向上转换为键入 B 和 list 成为 List[B] （这可能是由于协方差） 并像第一个一样继续。
   另请注意，由于存在 Any 和 Nothing 等类型，因此在两种类型之间“始终”存在 LUB。

现在让我们看看 Either 和 flatMap。

sealed trait Either[+L, +R] {
  def flatMap[LL >: L, RR](f: R => Either[LL, RR]): Either[LL, RR]
}

final case class Left[+L](l: L) extends Either[L, Nothing]
final case clas Right[+R](r: R) extends Either[Nothing, R]

现在，假设我的左侧是一个错误，我觉得这种在两个可能的左侧之间返回 LUB 的行为是最好的，因为最后我会遇到第一个错误，或者第二个错误或最终值，所以由于我不知道是这两个错误中的哪一个，因此该错误必须是某种类型，封装了这两个可能的错误。