如何实现隐式方法的中间类型？

Question

假设我想在我无法控制的现有类型 A 上提供方法 foo。据我所知，在 Scala 中执行此操作的规范方法是实现从 A 到某种实现 foo 的类型的隐式转换。现在我基本上看到两个选择。

1. 为此目的定义一个单独的，甚至可能是隐藏的类：

   受保护的类 Fooable(a : A) {
     def foo(...) = { ... }
   }
   隐式 def a2fooable(a : A) = new Fooable(a)
   

2. 定义一个内联匿名类：

   隐式 def a2fooable(a : A) = new { def foo(...) = { ... } }
   

变体 2) 肯定是更少的样板，尤其是当发生大量类型参数时。另一方面，我认为它应该会产生更多的开销，因为（概念上）每个转换创建一个类，而不是 1) 中全局创建一个类。

有一般准则吗？没有区别吗，因为编译器/VM 消除了 2) 的开销？

Answer 1

使用单独的类可以提高性能，因为替代方案可以使用反射。

考虑一下

new { def foo(...) = { ... } }

，现在

new AnyRef { def foo(...) = { ... } }

，AnyRef 没有方法foo。在 Scala 中，这种类型实际上是 AnyRef { def foo(...): ... }，如果删除 AnyRef，您应该将其识别为 结构类型。

在编译时，这个时间可以来回传递，并且在任何地方都知道方法 foo 是可调用的。然而，JVM 中没有结构类型，并且添加接口需要代理对象，这会导致一些问题，例如破坏引用相等（即，对象与其自身的结构类型版本不相等）。

解决这个问题的方法是使用结构类型的缓存反射调用。

因此，如果您想对任何性能敏感的应用程序使用 Pimp My Library 模式，请声明一个类。

Answer 2

我相信 1 和 2 会被编译为相同的字节码（除了在情况 2 中生成的类名之外）。
如果 Fooable 的存在只是为了让您能够将 A 隐式转换为 Fooable（并且您永远不会直接创建和使用 Fooable），那么我会选择选项 2。

但是，如果您控制 A（意味着 A 不是一个不能子类化的 java 库类）我会考虑使用特征而不是隐式转换来向 A 添加行为。

更新：
我必须重新考虑我的答案。我会使用你的代码的变体 1，因为变体 2 结果使用反射（Linux 上的 scala 2.8.1）。

我编译了相同代码的这两个版本，使用 jd-gui 将它们反编译为 java，结果如下：

带有命名类的

class NamedClass { def Foo : String = "foo" }

object test {
  implicit def StrToFooable(a: String) = new NamedClass 
  def main(args: Array[String]) { println("bar".Foo) }
}

源代码 带有匿名类的源代码

object test {
  implicit def StrToFooable(a: String) = new { def Foo : String = "foo" } 

  def main(args: Array[String]) { println("bar".Foo) }
}    

用 java-gui 编译并反编译为 java。 “命名”版本生成一个 NamedClass.class，该类被反编译为该 java：

public class NamedClass
  implements ScalaObject
{
  public String Foo()
  {
    return "foo";
  }
}

匿名生成一个 test$$anon$1 类，该类被反编译为以下 java

public final class test$anon$1
{
  public String Foo()
  {
    return "foo";
  }
}

，因此几乎相同，除了匿名是“最终”（他们显然希望为了额外确保你不会特意尝试对匿名类进行子类化...）

但是在调用站点我得到了这个用于“命名”版本的java

public void main(String[] args) 
{ 
  Predef..MODULE$.println(StrToFooable("bar").Foo());
}

，而这个是用于匿名的

  public void main(String[] args) { 
    Object qual1 = StrToFooable("bar"); Object exceptionResult1 = null;
    try { 
      exceptionResult1 = reflMethod$Method1(qual1.getClass()).invoke(qual1, new Object[0]); 
      Predef..MODULE$.println((String)exceptionResult1); 
      return; 
    } catch (InvocationTargetException localInvocationTargetException) { 
      throw localInvocationTargetException.getCause();
    }
  }

我用谷歌搜索了一下并发现其他人也报告了同样的事情但我还没有找到更多关于为什么会出现这种情况的见解。