为什么类型已知时对重载定义的引用不明确？

Question

我有一个像这样的功能：

def ifSome[B, _](pairs:(Option[B], B => _)*) {
  for((paramOption, setFunc) <- pairs)
    for(someParam <- paramOption) setFunc(someParam)
}

以及像这样的重载函数：

class Foo{ 
  var b=""
  def setB(b:String){this.b = b}
  def setB(b:Int){this.b = b.toString}
}

val f = new Foo

然后下面的行会产生错误：

ifSome(Option("hi") -> f.setB _)

<console>:11: error: ambiguous reference to overloaded definition,
both method setB in class Foo of type (b: Int)Unit
and  method setB in class Foo of type (b: String)Unit
match expected type ?
                 ifSome(Option("hi") -> f.setB _)

但是编译器知道我们正在寻找 Function1[java.lang.String, _]，那么为什么 Function1[Int, _] 的存在会带来任何混乱呢？我是否遗漏了一些东西，或者这是一个编译器错误（或者也许它应该是一个功能请求）？

我可以通过使用像这样的类型注释来解决这个问题

ifSome(Option("hi") -> (f.setB _:String=>Unit))

但我想了解为什么这是必要的。

Answer 1

您会想尝试

$ scalac -Ydebug -Yinfer-debug x.scala

，但首先您会想尽量减少。

在这种情况下，您将看到在柯里化版本中，B 是如何在第一个参数列表中解决的：

[infer method] solving for B in (bs: B*)(bfs: Function1[B, _]*)Nothing 
based on (String)(bfs: Function1[B, _]*)Nothing (solved: B=String)

对于未柯里化的版本，你会发现一些奇怪的地方

[infer view] <empty> with pt=String => Int

因为它试图消除过载的歧义，这可能会导致您找到下面奇怪的解决方案。

虚拟隐式的唯一目的是解决过载，以便推理可以继续进行。 隐式本身未使用且未实现

???

这是一个非常奇怪的解决方案，但你知道超载是邪恶的，对吧？ 你必须使用你可以使用的任何工具来对抗邪恶。

另请注意，您的类型注释解决方法比仅以正常方式指定类型参数更费力。

object Test extends App {
  def f[B](pairs: (B, B => _)*) = ???
  def f2[B](bs: B*)(bfs: (B => _)*) = ???

  def g(b: String) = ???
  def g(b: Int) = ???

  // explicitly
  f[String](Pair("hi", g _))

  // solves for B in first ps
  f2("hi")(g _)

  // using Pair instead of arrow means less debug output
  //f(Pair("hi", g _))

  locally {
    // unused, but selects g(String) and solves B=String
    import language.implicitConversions
    implicit def cnv1(v: String): Int = ???
    f(Pair("hi", g _))
  }

  // a more heavy-handed way to fix the type
  class P[A](a: A, fnc: A => _)
  class PS(a: String, fnc: String => _) extends P[String](a, fnc)
  def p[A](ps: P[A]*) = ???
  p(new PS("hi", g _))
}

Answer 2

Scala 中的类型推断仅适用于从一个参数

list 到下一个参数。由于您的 ifSome

 只有一个参数列表，Scala 不会推断任何内容。您可以按如下方式更改 

ifSome

：

def ifSome[B, _](opts:Option[B]*)(funs: (B => _)*) {
  val pairs = opts.zip(funs)
  for((paramOption, setFunc) <- pairs)
    for(someParam <- paramOption) setFunc(someParam)
}

让 Foo 保持原样...

class Foo{ 
  var b=""
  def setB(b:String){this.b = b}
  def setB(b:Int){this.b = b.toString}
}

val f = new Foo

并将呼叫相应地更改为

ifSome

：

ifSome(Option("hi"))(f.setB _) 这一切都有效。现在当然你必须检查

opts

 和 

funs

 在运行时是否具有相同的长度。