无锅板Scala ArrayBuilder专业化

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

因为它是唯一我们真正关心获取专业的+=方法，然后我们得到了add这是专门在Long一个Function1。与javap的检查，确实是我得到

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; 

为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]版本）。任何人都知道为什么这不起作用？与我提议的另一个相比，这种方法看起来相当干净。我想我希望能有一种更类似于宏观的专业化方法，但我想不能保证它对于所有的实例都是类型正确的，除非它为每个专业化选择相同的方法:(

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