4

在下面的代码块中（同时使用 scala2.11和2.12），该方法apply不会编译，而applyInlined可以。

package blar

trait Bar[T]

class A
class B
class C

trait Exploder[T] {
  // Removing explode and changing Foo so that
  // flatMap takes no param means it will compile
  def explode(product: C): Seq[T]
  val bar: Bar[T]
}

case object Exploder1 extends Exploder[A] {
  def explode(product: C): Seq[A] = ???
  val bar: Bar[A] = ???
}

case object Exploder2 extends Exploder[B] {
  def explode(product: C): Seq[B] = ???
  val bar: Bar[B] = ???
}

object Thing {
  def apply(): Unit = List(Exploder1, Exploder2).foreach {
    case exploder: Exploder[_] =>
      wrapped(exploder)
  }

  def applyInlined(): Unit = List(Exploder1, Exploder2).foreach {
    case exploder: Exploder[_] =>
      flatMap(exploder.explode)(exploder.bar)
  }

  def flatMap[U: Bar](explode: C => TraversableOnce[U]): Unit = ???

  def wrapped[T](exploder: Exploder[T]): Unit =
    flatMap(exploder.explode)(exploder.bar)
}

错误信息是

[error] .../src/main/scala/blar/Bar.scala:34:42: type mismatch;
[error]  found   : blar.Bar[_1]
[error]  required: blar.Bar[Object]
[error] Note: _1 <: Object, but trait Bar is invariant in type T.
[error] You may wish to define T as +T instead. (SLS 4.5)
[error]       flatMap(exploder.explode)(exploder.bar)
[error]                                          ^
[error] one error found
[error] (Compile / compileIncremental) Compilation failed
[error] Total time: 4 s, completed 03-Jan-2019 13:43:45
  1. 我的主要问题是为什么？这是一个错误吗？

如您所见applyInlined，不同之处在于它内联了wrapped方法的主体。这意味着某种方法中某些代码的额外包装以某种方式“欺骗”了编译器工作。

  1. 另一个问题是你能想出一个设计/黑客来避免这种事情而不产生Blar协变吗？如何使内联版本编译？我可以用一个asInstanceOf

  2. 什么是 scala 推断类型以便在wrapped没有显式类型参数的情况下调用？

4

1 回答 1

3

  1. 我不知道。实验证据表明，它[Exploder[_]]与List. 没有List[Exploder[_]]，列表的推断类型变为

    List[Product with Serializable with Exploder[_ >: B with A <: Object]]

    无论出于何种原因，它都会以某种方式打乱后续的模式匹配。B with A下限在我看来有点可疑，但我无法解释为什么它会干扰模式匹配。

  2. 不，幸运asInstanecOf的是，不需要 s。以下两种变体都可以正常工作：

    def applyInlined: Unit = List[Exploder[_]](Exploder1, Exploder2).foreach {
  case exploder: Exploder[t] => {
    flatMap(exploder.explode)(exploder.bar)
  }
}

    与单独声明的隐式变量相同（请注意，现在您t可以引用一些类型）：

    def applyInlined2: Unit = List[Exploder[_]](Exploder1, Exploder2).foreach {
  case exploder: Exploder[t] => {
    implicit val bar: Bar[t] = exploder.bar
    flatMap(exploder.explode)
  }
}

    有关-part的更多信息，请参阅模式中的类型参数推断。[t]

  3. 我认为它是一些合成虚拟类型_1。

于 2019-01-03T14:55:14.717 回答