是 PartFunction or Else 在其类型边界上比应有的更宽松

Question

让我们定义一个PartialFunction[String, String]和一个PartialFunction[Any, String]

现在，鉴于orElse的定义

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

我希望无法将两者组合在一起，因为

A → String A1 → Any

因此，绑定A1 <: A(即 Any <: String ( 不成立。

出乎意料的是，我可以编写它们并获得在整个String域上定义的PartialFunction[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？

如果编译器从b推断A1，那么它必须是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处于逆变位置
• String和String最不常见的超类型，因为B和B1是协变位置

结果

• A1 → String
• B1 → String

---

将 PartialFunction[String, String] 与 PartialFunction[Int, Int] 组合的情况是上一个示例的一个奇怪的情况，其中：

• String和Int的最大常见亚型是String with Int，即两种类型的交集，这是两者的子类型(在这种情况下几乎就像说Nothing：既是String又是Int似乎不太可能(
• 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...

Answer 2

我要

说PartialFunction[Any, String]是PartialFunction[String, String]的一个子类型，因为如果我理解正确的话，会产生逆方差。这将解释您在更新之前的问题中描述的行为，但是您让我都与这种联合类型的东西混淆了。

我什至不知道String with Int到底是什么意思！

Answer 3

这当然是模糊的，只是我的拙见。欢迎提出建议和意见。

从这个SO问题中获取。(如何知道对象是否是 TypeTag 类型的实例？

import scala.reflect.runtime.universe._
implicit class MyInstanceOf[U: TypeTag](that: U) {
  def myIsInstanceOf[T: TypeTag] = 
    typeOf[U] <:< typeOf[T]
}

我们有一种正确的方法来检查isInstanceOf而不会擦除。

val b: PartialFunction[Any, String] = { case _ => "default" }
b.myIsInstanceOf[PartialFunction[String, String]] //true

这才有意义。如果您有来自 Any => String 的函数，则它接受任何输入。因此，它也接受String输入。这就是为什么它也可以被视为来自String => String的函数。基本上它可以被视为任何T的T => String。

所以最后编译器同意A -> String和A1 -> String.

 a.orElse[String,String](b) //works

编辑：最后的想法

您不应将A1 <: A视为一种限制。它只会推断结果PartialFunction的类型。没有办法不能应用orElse。所涉及的两种PF在A上都是逆变的，因此总能找到满足A1 <: A的BOTH的共同亚型。

我认为一个类比是分数的加法，你会想，哦，它们没有公分母，因此不能相加。两个分数都可以调整(或：以不同的方式看待(以具有共同分母。编译器虽然希望找到最小的公分母，而不是诉诸与另一个分母相乘的简单方法。( A with A' (

对于另一种类型B它是相同的。两者都是协变的，因此也总能找到一个共同的超类型。 Any最坏的情况下。

Answer 4

你已经输入了这个，但是：

scala> val a: PartialFunction[String, String] = { case "a" => "b" }
a: PartialFunction[String,String] = <function1>
scala> val b: PartialFunction[Any, String] = { case 1 => "one" }
b: PartialFunction[Any,String] = <function1>
scala> a orElse b
res0: PartialFunction[String,String] = <function1>
scala> a orElse[String,String] b
res1: PartialFunction[String,String] = <function1>
scala> a orElse[Any,String] b
<console>:10: error: type arguments [Any,String] do not conform to method orElse's type parameter bounds [A1 <: String,B1 >: String]
              a orElse[Any,String] b
              ^
scala> import reflect.runtime._ ; import universe._
import reflect.runtime._
import universe._
scala> typeOf[PartialFunction[Any,String]] <:< typeOf[PartialFunction[String,String]]
res3: Boolean = true

由于逆变类型参数，您可以在此处使用 PF[Any， String]。

要回答这个问题，它在哪里说它会选择什么？

http://www.scala-lang.org/files/archive/spec/2.11/06-expressions.html#local-type-inference

例如，它承诺在逆变位置推断最大 A1，但仍符合约束<：A。