Question

是否可以在Scala中专门化通用函数（或类）？例如，我想编写一个将数据写入ByteBuffer的通用函数：

def writeData[T](buffer: ByteBuffer, data: T) = buffer.put(data)

但是由于put方法只需要一个字节并将其放入缓冲区，我需要将它专门用于Ints和Longs，如下所示：

def writeData[Int](buffer: ByteBuffer, data: Int) = buffer.putInt(data)
def writeData[Long](buffer: ByteBuffer, data: Long) = buffer.putLong(data)

它不会编译。当然，我可以分别编写3个不同的函数writeByte，writeInt和writeLong，但是假设有一个数组的另一个函数：

def writeArray[T](buffer: ByteBuffer, array: Array[T]) {
  for (elem <- array) writeData(buffer, elem)
}

如果没有专门的writeData函数，这将无法工作：我将不得不部署另一组函数writeByteArray，writeIntArray，writeLongArray。每当我需要使用类型相关的写函数时，必须以这种方式处理这种情况并不酷。我做了一些研究，一个可能的解决方法是测试参数的类型：

def writeArray[T](buffer: ByteBuffer, array: Array[T]) {
  if (array.isInstanceOf[Array[Byte]])
    for (elem <- array) writeByte(buffer, elem)
  else if (array.isInstanceOf[Array[Int]])
    for (elem <- array) writeInt(buffer, elem)
  ...
}

这可能有效，但效率较低，因为类型检查是在运行时完成的，与专用函数版本不同。

所以我的问题是，在Scala或Java中解决此类问题的最理想和首选方法是什么？我提前感谢您的帮助！

Answer 1

如果你能同时拥有一个紧凑而有效的解决方案，那不是很好吗？事实证明，鉴于Scala的@specialized功能，您可以。首先警告：该功能有些错误，如果你试图将它用于太复杂的东西，可能会破坏。但对于这种情况，它几乎是完美的。

@specialized注释为每种基本类型创建单独的类和/或方法，然后每当编译器确定原始类型是什么时调用它而不是通用版本。唯一的缺点是它完全自动完成所有这些 - 你无法填写自己的方法。这有点遗憾，但你可以使用类型类来克服这个问题。

让我们看看一些代码：

import java.nio.ByteBuffer
trait BufferWriter[@specialized(Byte,Int) A]{
  def write(b: ByteBuffer, a: A): Unit
}
class ByteWriter extends BufferWriter[Byte] {
  def write(b: ByteBuffer, a: Byte) { b.put(a) }
}
class IntWriter extends BufferWriter[Int] {
  def write(b: ByteBuffer, a: Int) { b.putInt(a) }
}
object BufferWriters {
  implicit val byteWriter = new ByteWriter
  implicit val intWriter = new IntWriter
}

这为我们提供了一个通用的BufferWriter特征，但是我们使用适当的实现覆盖了我们想要的每个特定基本类型（在本例中为Byte和Int）。专业化足够聪明，可以将此显式版本与通常用于专业化的隐藏版本链接起来。所以你有自定义代码，但是你如何使用它？这就是隐含的val进来的地方（我已经这样做了速度和清晰度）：

import BufferWriters._
def write[@specialized(Byte,Int) A: BufferWriter](b: ByteBuffer, ar: Array[A]) {
  val writer = implicitly[BufferWriter[A]]
  var i = 0
  while (i < ar.length) {
    writer.write(b, ar(i))
    i += 1
  }
}

A: BufferWriter表示法意味着为了调用此write方法，您需要使用隐式BufferWriter[A]。我们在BufferWriters中为他们提供了val，所以我们应该设置。让我们看看这是否有效。

val b = ByteBuffer.allocate(6)
write(b, Array[Byte](1,2))
write(b, Array[Int](0x03040506))
scala> b.array
res3: Array[Byte] = Array(1, 2, 3, 4, 5, 6)

如果你把这些东西放在一个文件中，并开始用javap -c -private来探索类，你会看到正在使用适当的原始方法。

（注意，如果你没有使用专门化，这个策略仍然可以工作，但是它必须在循环内部装箱值以复制数组。）

Answer 2

使用类型类模式。它具有优于instanceOf检查（或模式匹配）类型安全的优势。

import java.nio.ByteBuffer

trait BufferWriter[A] {
  def write(buffer: ByteBuffer, a: A)
}

class BuffPimp(buffer: ByteBuffer) {
  def writeData[A: BufferWriter](data: A) = { 
    implicitly[BufferWriter[A]].write(buffer, data)
  }
}

object BuffPimp {
  implicit def intWriter = new BufferWriter[Int] {
    def write(buffer: ByteBuffer, a: Int) = buffer.putInt(a)
  }
  implicit def doubleWriter = new BufferWriter[Double] {
    def write(buffer: ByteBuffer, a: Double) = buffer.putDouble(a)
  }
  implicit def longWriter = new BufferWriter[Long] {
    def write(buffer: ByteBuffer, a: Long) = buffer.putLong(a)
  }
  implicit def wrap(buffer: ByteBuffer) = new BuffPimp(buffer)
}

object Test {
  import BuffPimp._
  val someByteBuffer: ByteBuffer
  someByteBuffer.writeData(1)
  someByteBuffer.writeData(1.0)
  someByteBuffer.writeData(1L)
}

所以这段代码不是类型类的最佳演示。我对他们还很新。该视频非常可靠地概述了它们的优点以及如何使用它们：http://www.youtube.com/watch?v=sVMES4RZF-8

Answer 3

声明

def writeData[Int](buffer: ByteBuffer, data: Int) 
def writeData[Long](buffer: ByteBuffer, data: Long)

不编译因为它们是等价的，因为Int和Long是formal类型参数而不是标准的Scala类型。要使用标准Scala类型定义函数，只需编写：

def writeData(buffer: ByteBuffer, data: Int) = buffer.putInt(data)
def writeData(buffer: ByteBuffer, data: Long) = buffer.putLong(data)

这样您可以使用相同的名称声明不同的函数。

由于它们是不同的函数，因此您无法将它们应用于静态未知类型的List的元素。您首先要确定List的类型。注意，可能发生List的类型是AnyRef，然后您已动态确定每个元素的类型。您可以使用原始代码中的isInstanceOf或使用模式匹配来确定rolve。我认为这会产生相同的字节码。
总而言之，您必须选择：
- 具有多个函数的快速代码，例如writeByteArray, writeIntArray等。它们都可以具有相同的名称writeArray，但可以通过其实际参数进行静态区分。 Dominic Bou-Sa建议的变体属于这种类型。
- 使用运行时类型确定的简洁但速度慢的代码

不幸的是，你不能同时拥有快速和简洁的代码。

Answer 4

这个怎么样：

def writeData(buffer: ByteBuffer, data: AnyVal) {
  data match {
    case d: Byte => buffer put d
    case d: Int  => buffer putInt d
    case d: Long => buffer putLong d
    ...
  }
}

在这里，您在writeData方法中区分大小写，这使得所有其他方法变得非常简单：

def writeArray(buffer: ByteBuffer, array: Array[AnyVal]) {
  for (elem <- array) writeData(buffer, elem)
}

优点：简单，简洁，易于理解。

缺点：如果您不处理所有AnyVal类型，则不完全类型安全：有人可能会调用writeData(buffer, ())（第二个参数类型为Unit }），这可能会导致运行时出错。但是你也可以处理() no-op，它解决了这个问题。完整的方法如下所示：

def writeData(buffer: ByteBuffer, data: AnyVal) {
  data match {
    case d: Byte   => buffer put d
    case d: Short  => buffer putShort d
    case d: Int    => buffer putInt d
    case d: Long   => buffer putLong d
    case d: Float  => buffer putFloat d
    case d: Double => buffer putDouble d
    case d: Char   => buffer putChar d
    case true      => buffer put 1.asInstanceOf[Byte]
    case false     => buffer put 0.asInstanceOf[Byte]
    case ()        =>
  }
}

顺便说一句，由于Scala严格的面向对象性质，这只能轻松实现。在Java中，基本类型不是对象，这将更加麻烦。在那里，你实际上必须为每个基元类型创建一个单独的方法，除非你想做一些丑陋的装箱和拆箱。

Scala（或Java）中泛型函数的专业化

4 个答案: