5

让我们定义一个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(ie 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]
4

4 回答 4

4

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

我什至不知道他妈是什么String with Int意思！

于 2014-08-20T00:04:09.040 回答
4

你把这颠倒了。

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

def foo(a: Animal)

你可以传递一个Dogto foo，因为Dog <: Animal.

同样的，如果你有

def foo(l: List[Animal])

您可以将 a 传递List[Dog]给它，因为List它与它的类型参数协变，并且因为Dog <: Animal, 那么List[Dog] <: List[Animal]

现在如果你有

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

您可以传递 a PartialFunction[Any, String]，因为PartialFunction它与第一个类型参数逆变并与第二个类型参数协变。既然Any >: String，那么PartialFuncion[Any, String] <: PartialFunction[String, String]。

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

  • A1是的子类型A
  • B2是的子类型B

为此，它将寻找：

  • 和 的最大常见子类型Any，String因为A和A1处于逆变位置
  • Stringand的最不常见的超类型String，因为BandB1是协变位置

结果

  • A1→String
  • B1→String

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

  • Stringand最常见的子类型Int是String with Int，即两种类型的交集，它是两者的子类型（在这种情况下几乎可以说Nothing：既是aString又是 anInt似乎不太可能）
  • 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...
于 2014-08-20T01:48:07.377 回答
1

这当然是模糊的，只是我的拙见。建议和意见表示赞赏。

取自这个 SO question。（如何知道一个对象是否是 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 => String任何T.

所以最后编译器同意A -> Stringand A1 -> String。

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

编辑：最后的想法

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

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

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

于 2014-08-20T00:12:42.763 回答
1

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

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-in​​ference

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

于 2014-08-20T00:31:12.150 回答