为什么 Scala 不选择这个类型类中最具体的实例？

Question

我正在努力在 Scala 中构建这个计算管道构建器。我想要一个有两种方法的类，map 和reduce，它们在“流利的接口”中接收匿名函数。这些函数将被组合起来，所以我想对所有函数进行类型检查，同时还要从之前的方法调用中推断出它们的输入类型......参见我的related question（这都是谜题的一部分）。

我所有的问题都把问题简单化了，但答案很有帮助，我想我快到了。

只要我有注册具有KeyVal 输出的映射器函数时使用的特殊方法，我就设法使一切正常工作。但我想为这些函数使用相同的 map 名称，并总体上简化架构。为此，我决定尝试使用类型类模式。这允许我根据构建器方法参数中的函数类型做不同的事情。请记住，我的问题的一部分是，如果我给mapper 方法提供一个输出KeyVal[K,V] 类型（几乎是一个元组）的函数，我需要将这个K 和V 存储为来自我的构建器类的类型参数，因此它们可用于稍后从 reducer 方法中进行类型检查/推断类型。

这是我的构建器类

case class PipelineBuilder[A, V](commandSequence: List[MRBuildCommand]) {

  trait Foo[XA, XB, +XV] {
    def constructPB(xs: XA => XB): PipelineBuilder[XB, XV]
  }

  implicit def fooAny[XA, XB]: Foo[XA, XB, Nothing] = new Foo[XA, XB, Nothing] {
    def constructPB(ff: XA => XB) = PipelineBuilder[XB, Nothing](MapBuildCommand(ff) :: commandSequence)
  }

  implicit def fooKV[XA, XK, XV]: Foo[XA, KeyVal[XK,XV], XV] = new Foo[XA, KeyVal[XK,XV], XV] {
    def constructPB(ff: XA => KeyVal[XK,XV]) = PipelineBuilder[KeyVal[XK,XV], XV](MapBuildCommand(ff) :: commandSequence)
  }

  def innermymap[AA, FB, FV](ff: AA => FB)(implicit mapper: Foo[AA, FB, FV]) = mapper.constructPB(ff)

  def mymap[FB](ff: A => FB) = innermymap(ff)


  def rreduce[K](newFun: (V, V) => V)(implicit ev: KeyVal[K, V] =:= A) =
    PipelineBuilder[A,V](RedBuildCommand[K, V](newFun) :: commandSequence)

  def output(dest: MRWorker) = constructPipeline(dest)
  //...

}

这就是类在主程序中的使用方式

object PipelineLab extends App {

  val mapredPipeline = PipelineBuilder[String, Nothing](List())
    .mymap { s: String => s.toLowerCase }
    .mymap { s: String => KeyVal(s, 1) }
    .rreduce(_ + _)
    .output(OutputWorker)
  // ...
}

请注意，s: String 不是必需的，因为如果类型参数 A 来自类。 rreduce 中的 V 也是如此。

我已经设法在下面的简单示例中使用了类型类模式。如果我输出一个元组，它会做一些不同的事情......就是这样。

object TypeClassLab extends App {

  trait FuncAdapter[A, B] {
    def runfunc(x: A, f: A => B): B
  }

  implicit def myfunplain[X, A]: FuncAdapter[X, A] = new FuncAdapter[X, A] {
    def runfunc(x: X, f: X => A): A = {
      println("Function of something to plain, non-tuple type")
      f(x)
    }
  }

  implicit def myfuntuple[X, AA, AB]: FuncAdapter[X, (AA, AB)] = new FuncAdapter[X, (AA, AB)] {
    def runfunc(x: X, f: X => (AA, AB)): (AA, AB) = {
      println("Function from String to tuple")
      f(x)
    }
  }

  def ffuunn[A, B](x: A)(f: A => B)(implicit fa: FuncAdapter[A, B]) = {
    fa.runfunc(x, f)
  }

  println(ffuunn("obaoba") { s => s.length })
  println(ffuunn("obaobaobaobaoba") { s => s.length })
  println(ffuunn("obaoba") { s => (s.length, s.reverse) })
  println(ffuunn("obaobaobaobaoba") { s => (s.length, s.reverse) })
}
//OUTPUT:
//Function of something to plain, non-tuple type
//6
//Function of something to plain, non-tuple type
//15
//Function from String to tuple
//(6,aboabo)
//Function from String to tuple
//(15,aboaboaboaboabo)

像魅力一样工作。但后来我无法适应我的真正问题......现在编译器似乎不是在寻找更具体的fooKV 隐式，而是总是选择fooAny，当我尝试时会导致错误运行rreduce，因为它期待V <: Nothing。如何让它发挥作用？

Answer 1

我不确定我是否完全理解您的问题。

就选择fooAny 与fooKV 而言，Foo 的实例必须是已知的，并且必须从已知类型的站点适当地传递。这将是调用mymap 的地方。 Foo 虽然没有作为参数传递。

def mymap[FB](ff: A => FB) = innermymap(ff)

您需要知道何时调用innermymap(ff)。此时，类型信息丢失。 Foo 的唯一可用实例是 fooAny。

这实际上是一个示例，说明为什么不应该存在像 fooAny 这样的定义。您正在定义任何XA 和任何XB 之间的有效关系，即使它们实际上只是Any。此定义的存在导致您的代码在不应该进行类型检查时进行类型检查。这很可能会再次发生。