scala - PartialFunction orElse 的类型界限是否比它应该的更宽松？

Question

让我们定义一个 PartialFunction[String, String]和一个 PartialFunction[Any, String]
现在，给定 orElse 的定义

def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1] 

我希望不能将两者组合起来，因为
A → StringA1 → Any
因此界限 A1 <: A (即 Any <: String )不成立。

没想到，我可以组合它们并获得PartialFunction[String, String]整体定义String领域。下面是一个例子:

val a: PartialFunction[String, String] = { case "someString" => "some other string" }
// a: PartialFunction[String,String] = <function1>

val b: PartialFunction[Any, String] = { case _ => "default" }
// b: PartialFunction[Any,String] = <function1>

val c = a orElse b
// c: PartialFunction[String,String] = <function1>

c("someString")
// res4: String = some other string

c("foo")
// res5: String = default

c(42)
// error: type mismatch;
//   found   : Int(42)
//   required: String

此外，如果我明确提供 orElse类型参数

a orElse[Any, String] b
// error: type arguments [Any,String] do not conform to method orElse's type parameter bounds [A1 <: String,B1 >: String]

编译器终于显示出一些意义。

是否有任何我遗漏的类型系统巫术导致 b成为 orElse 的有效参数?换句话说，怎么会出现A1推断为 String ?

如果编译器推断 A1来自 b那么它必须是 Any ，那么导致 String 的推理链还在哪里？开始？

更新

在玩过 REPL 后，我注意到 orElse返回一个交集类型 A with A1当类型不匹配时。例子:

val a: PartialFunction[String, String] = { case "someString" => "some other string" }
// a: PartialFunction[String,String] = <function1>

val b: PartialFunction[Int, Int] = { case 42 => 32 }
// b: PartialFunction[Int,Int] = <function1>

a orElse b
// res0: PartialFunction[String with Int, Any] = <function1>

自 (String with Int) <:< String这有效，即使结果函数实际上无法使用。我也怀疑 String with Any统一为Any ， 鉴于

import reflect.runtime.universe._
// import reflect.runtime.universe._   

typeOf[String] <:< typeOf[String with Any]
// res1: Boolean = true

typeOf[String with Any] <:< typeOf[String]
// res2: Boolean = true

所以这就是混合 String 的原因和 Any结果变成String .

话虽如此，引擎盖下发生了什么？错配类型统一在什么逻辑下？

更新 2

我已将问题简化为更一般的形式:

class Foo[-A] {
  def foo[B <: A](f: Foo[B]): Foo[B] = f
}

val a = new Foo[Any]
val b = new Foo[String]

a.foo(b) // Foo[String] Ok, String <:< Any
b.foo(a) // Foo[String] Shouldn't compile! Any <:!< String
b.foo[Any](a) // error: type arguments [Any] do not conform to method foo's type parameter bounds [A <: String]

Answer 1

你把这倒过来了。

您始终可以传递给需要 A 类型参数的方法。任何类型的参数 B <: A ，即 A 的任何子类型.也就是说，如果你有

def foo(a: Animal)

您可以通过 Dog至 foo , 因为 Dog <: Animal .

同理，如果你有

def foo(l: List[Animal])

您可以通过 List[Dog]到它，因为List与其类型参数协变，因为 Dog <: Animal ，然后 List[Dog] <: List[Animal]
现在如果你有

def foo(pf: PartialFunction[String, String])

您可以通过 PartialFunction[Any, String] , 因为 PartialFunction与第一个类型参数逆变，与第二个类型参数协变。自 Any >: String ，然后 PartialFuncion[Any, String] <: PartialFunction[String, String] .

现在，对于类型边界，编译器将尝试推断 A1和 B1 ，这样

A1是 A 的子类型

B2是 B 的子类型

为此，它将寻找:

Any的最大常见亚型和 String , 自 A和 A1处于逆变位置

最不常见的父类(super class)型 String和 String , 自 B和 B1是协变位置

结果

A1 → String

B1 → String

您编写 PartialFunction[String, String 的情况] 带有 PartialFunction[Int, Int]是前一个例子的一个奇怪的例子，其中:

String的最大常见亚型和 Int是 String with Int ，即两种类型的交集，它是两者的子类型(在这种情况下几乎就像在说 Nothing :同时是 String 和 Int 似乎不太可能)

最不常见的父类(super class)型 String和 Int是 Any

所以

val a: PartialFunction[String, String] = ...
val b: PartialFunction[Int, Int] = ...
a orElse b // PartialFunction[String with Int, Any] // as expected, although not very useful...