Question

我正在寻找好的做法，以避免一遍又一遍地重写相同的代码以实现无箱功能。说我有这样的事情：

def speedyArrayMaker[@specialized(Long) A: ClassTag](...): Array[A] = {
  val builder = Array.newBuilder[A]
  // do stuff with builder
  builder.result
}

这会在可能的情况下导致我builder下的未装箱存储，但据我所知，没有任何未装箱的方法会调用它，因为我正在浏览非专业化的ArrayBuilder特征。

在一个专注于Long的单形世界中，我会写val builder = new ArrayBuilder.ofLong()并完全避免拳击，但不能告诉ArrayBuilder / Builder专注于所有原始类型，我想不出一个避免重复努力的好方法。我想到的一种方法可能是speedyArrayMaker：

val (add, builder): (A => Unit, ArrayBuilder[A]) = implicitly[ClassTag[A]].runtimeClass match {
  case java.lang.Long.TYPE =>
    val builder = new ArrayBuilder.ofLong()
    ((x: Long) => builder += x, builder).asInstanceOf
  case _ =>
    val builder = Array.newBuilder[A]
    ((x: A) => builder += x, builder)
}

由于我们只关注+=方法，因此我们得到Function1 add Long专门用于90: invokestatic #118; //Method scala/runtime/BoxesRunTime.boxToLong:(J)Ljava/lang/Long; 93: invokeinterface #127, 2; //InterfaceMethod scala/collection/mutable/Builder.$plus$eq:(Ljava/lang/Object;)Lscala/collection/mutable/Builder;。用javap检查，确实我得到了

Array.newBuilder[A]

用于252: invokeinterface #204, 3; //InterfaceMethod scala/Function1.apply$mcVJ$sp:(J)V版本（即使在专门的输出中）和：

Function1

对于复杂的版本。我可以将这个模式打包成一个“专门的构建器助手”函数，但是它感觉很难看，特别是当它仍然在运行时根据在特化期间编译时已知的事情进行调度时。最后我要说我的建议是捎带ArrayBuilder.of*已经专门化的事实，我并不特别喜欢它。

我可以使用巧妙的技巧让这更愉快吗？我意识到这是一个非常低级的细节，并且很少会对性能至关重要，但考虑到所有def builderOf(x: Array[Int]): ArrayBuilder.ofInt = new ArrayBuilder.ofInt() def builderOf(x: Array[Long]): ArrayBuilder.ofLong = new ArrayBuilder.ofLong() def builderOf[A: ClassTag](x: Array[A]): ArrayBuilder[A] = ArrayBuilder.make[A]专业类的工作量/代码重复，看起来很可惜丢掉一些他们的以多态性换取优势。

修改我想到了一些丑陋的东西，但我希望能有效：

val witness: Array[A] = null
val builder = builderOf(witness)

然后在我的专业功能中：

builderOf

但它似乎甚至在专用版本中调用泛型Array[Long]（即使有足够的类型信息可用于调用{{1}}版本）。任何人都知道为什么这不起作用？与我提议的另一个相比，这种方法看起来相当干净。我想我希望有一种更像“宏观”的专业化方法，但我想不可能保证它对所有实例化都是类型正确的，除非它为每个专业化选择相同的方法：（

Answer 1

你可以尝试一些事情（原谅野蛮的名字），

import scala.collection.mutable.ArrayBuilder
import scala.reflect.ClassTag

trait SpecializedArrayBuilder[@specialized(Long) A] {
  def +=(a: A)
  def result: Array[A]
}

trait LowPrioritySpecializedArrayBuilder {
  implicit def defaultBuilder[A: ClassTag] = new SpecializedArrayBuilder[A] {
    val builder = ArrayBuilder.make[A]
    def +=(a: A) = builder += a
    def result = builder.result
  }
}

object SpecializedArrayBuilder extends LowPrioritySpecializedArrayBuilder {
  implicit val longBuilder = new SpecializedArrayBuilder[Long] {
    val builder = new ArrayBuilder.ofLong
    def +=(a: Long) = builder += a
    def result = builder.result
  }
}

object Specialized {
  def speedyArrayMaker[@specialized(Long) A](a: A)
    (implicit builder: SpecializedArrayBuilder[A]): Array[A] = {
    builder += a
    builder.result
  }

  def main(arg: Array[String]) {
    val arr = speedyArrayMaker(1L)
    println(arr)
  }
}

Boilerplate-free Scala ArrayBuilder专业化

1 个答案: