Question

我得到一个奇怪的编译器错误，关于实际存在的隐式但由于某种原因无法找到。因此，我构建了一个小型测试用例，可以重现神秘的行为。

trait Hide {
  type T
}
object HideString extends Hide {
  override type T = String
}
object HideBool extends Hide {
  override type T = Boolean
}

简单类型用作隐式转换的明确目标。

def id[H <: Hide, C](x : C)(implicit ev : C => H#T) : H#T = ev(x)
def drop[H <: Hide, C](x : C)(implicit ev : C => H#T) : Int = {
  println(ev(x))
  1
}
def idSeq[H <: Hide, C](x : Seq[C])(implicit ev : Seq[C] => Seq[H#T]) : Seq[H#T] = ev(x)
def dropSeq[H <: Hide, C](x : Seq[C])(implicit ev : Seq[C] => Seq[H#T]) : Int = {
  println(ev(x))
  1
}

依赖隐式转换的方法。它基本上是2x2矩阵。 id方法返回转换后的类型，drop方法在内部使用转换并返回一些常量。普通方法在精确隐式转换类型上运行，Seq方法在序列上运行。

implicit def exString(x : String) : HideString.type#T = x
implicit def highString[F[_]](x : F[String]) : F[HideString.type#T] = x

以上隐式转换highString是使用高阶类型定义的。

val s1 = id("sdf")
val s2 = drop("aero")

val r1 = idSeq(Seq("a", "bc"))
val r2 = dropSeq(Seq("i", "IO"))

尝试实际使用转换会给我带来错误：

ImplicitResolution.scala:98: error: No implicit view available from Seq[String] => Seq[test.implicits.HighReduction.Hide#T].
  val r2 = dropSeq(Seq("i", "IO"))

可以在以下矩阵中进行总结：

|        | id   | drop |
|--------+------+------|
| normal | pass | pass |
| seq    | pass | fail |

如果我对dropSeq方法使用精确定义的隐式转换，则通常会找到：

implicit def seqBool(x : Seq[Boolean]) : Seq[HideBool.type#T] = x

val a1 = idSeq(Seq(true, false))
val a2 = dropSeq(Seq(false, true))

此外，如果我明确指定隐式参数dropSeq开始起作用：

val r2i = dropSeq(Seq("i", "IO"))(highString[Seq] _)

这是最奇怪的事情。 highString隐含符合所有要求。它被声明为implicit，因此它应该由编译器找到。在idSeq的情况下，实际上找到了它。那么，为什么在dropSeq案例中忽略它？

Answer 1

在您的情况下，idSeq和dropSeq之间的唯一区别是返回类型：您已经在Scala编译器中遇到了一些值得向Scala社区发出信号的案例。

也就是说，你的idSeq签名错误：H#X并不代表指定H类型的X类型，而是X代表任何H的实例（不是一个）已由编译器解决，请参阅Daniel Sobral在此解释What does the `#` operator mean in Scala?）

您可能想要做的是在H和结果类型之间建立关系，如果您引入类型别名以获得更可读的签名，则更容易：

object Hide {
  type HideAux[X] = Hide { type T = X}
}

然后您可以像这样重写代码：

  def idSeq[B,H <: HideAux[B], C](x : Seq[C])(implicit ev : Seq[C] => Seq[B]) : Seq[B] = ev(x)
  def dropSeq[B,H <: HideAux[B], C](x : Seq[C])(implicit ev : Seq[C] => Seq[B]) : Int = {
    println(ev(x))
    1
  }

此代码编译，并注意如果您正确使用泛型和类型类，则不需要两种不同的方法id和idSeq，因为动态行为将由类型类本身提供

为什么在某些情况下会忽略高阶隐含？

1 个答案: