4

我有这样的功能：

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))

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

4

2 回答 2

2

Scala 中的类型推断仅适用于从一个参数列表到下一个参数列表。由于您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具有相同的长度。

于 2012-09-28T22:34:31.760 回答
2

你会想尝试$ scalac -Ydebug -Yinfer-debug x.scala，但首先你会想最小化。

在这种情况下，您将看到在 curried 版本中，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 _))
}
于 2012-09-29T05:13:24.140 回答