How do I use Scala @specialized for a memory-efficient wrapper class around a primitive?

Question

I have a wrapper class that can store a Long, Double, or Boolean primitive value (as well as some other stuff that I've removed for simplicity). My original naive implementation just stored the wrapped value in a field of type Any, which resulted in the values being boxed. To remove the boxing and reduce memory usage, I tried using generics, but learned that due to type erasure, this doesn't save anything. So I tried using @specialized, but got surprising results. The below code was built with scalac 2.9.3 and run on JDK7. MemoryMeasurer comes from here and I believe it to be accurate. The "padding" field isn't significant; I am just using it to pad the base object (without the wrapped value) to 16 bytes, so the effect of my various attempts is more clear. ``` import objectexplorer.MemoryMeasurer class GenericNonSpecialized[A] (wrapped: A, val padding: Int) { def getWrapped: Any = wrapped } class GenericSpecialized[@specialized(Long, Double, Boolean) A] (wrapped: A, val padding: Int)…

Accepted Answer

Unfortunately, specialized classes inherit from their non-specialized parent, and that one contains storage space for a boxed copy. The short answer therefore is that you can't form an efficient wrapper this way.

You can declare the data in a trait:

```
trait Boxer[@specialized A]{ def boxed: A }
```

and then provide implementations manually:

```
class BoxerInt(val boxed: Int) extends Boxer[Int]
class BoxerDouble(val boxed: Double) extends Boxer[Double]
```

and then write the Boxer companion to overload the apply method:

```
object Boxer {
  def apply(i: Int) = new BoxerInt(i)
  def apply(d: Double) = new BoxerDouble(d)
}
```

so that you can make it look like you didn't have to do all that work:

```
val box = Boxer(5.0)
```

but it still isn't completely seamless with other uses of specialization (in particular creation in a generic context will always be an issue).

How do I use Scala @specialized for a memory-efficient wrapper class around a primitive?

Solution

Problem