Scala Pickling and type parameters

Question

I'm using Scala Pickling, an automatic serialization framework for Scala. According to the author's slides, any type T can be pickled as long as there is an implicit Pickler[T] in scope. Here, I'm assuming she means scala.tools.nsc.io.Pickler. However, the following does not compile:

import scala.pickling._
import scala.pickling.binary._
import scala.tools.nsc.io.Pickler

object Foo {
  def bar[T: Pickler](t: T) = t.pickle
}

The error is:

[error] exception during macro expansion:
[error] scala.ScalaReflectionException: type T is not a class
[error]     at scala.reflect.api.Symbols$SymbolApi$class.asClass(Symbols.scala:323)
[error]     at scala.reflect.internal.Symbols$SymbolContextApiImpl.asClass(Symbols.scala:73)
[error]     at scala.pickling.PickleMacros$class.pickleInto(Macros.scala:381)
[error]     at scala.pickling.Compat$$anon$17.pickleInto(Compat.scala:33)
[error]     at scala.pickling.Compat$.PickleMacros_pickleInto(Compat.scala:34)

I'm using Scala 2.10.2 with scala-pickling 0.8-SNAPSHOT.

Is this a bug or user error?

EDIT 1: The same error arises with both scala.pickling.SPickler and scala.pickling.DPickler.

EDIT 2: It looks like this is a bug: https://github.com/scala/pickling/issues/31

I also took recent interest in this project (I believe Heather Miller the creator mentioned it on Stackoverflow on another post).. but I just couldn't find many good examples to get going. Macros are fairly complex based on my current learning curve with Scala, so I wish there were more examples out there. Same applies with Twitter Chill! — LaloInDublin, Sep 10 '13 at 18:39
A quick look at the implementation suggests that what you need is not a `scala.tools.nsc.io.Pickler` but a `scala.pickling.SPickler` (or `scala.pickling.DPickler`). Just change your definition to `def bar[T: SPickler](t: T) = t.pickle` and see how it goes. — Régis Jean-Gilles, Sep 10 '13 at 19:20
Yep, as you've already surmised, but to confirm anyway, you need a `scala.pickling.SPickler` or `scala.pickling.DPickler`. Pay no attention to `scala.tools.nsc.io.Pickler` (this is used by the Scala compiler to pickle/unpickle class files) — Heather Miller, Sep 11 '13 at 14:12
And yep, you're right that there was a pickling/unpickling bug when it came to the pickling framework dealing with abstract types. Thanks for reporting, and hanging in there with us :) — Heather Miller, Sep 11 '13 at 16:38

score 10 · Accepted Answer · answered Sep 11 '13 at 16:37

Yep, as Andy pointed out:

you need either a scala.pickling.SPickler or a scala.pickling.DPickler (static and dynamic, respectively) in order to pickle a particular type.

Those both already come in the scala.pickling package, so it's enough to just use them in your generic method signature.

You're absolutely correct that you can add an SPickler context-bound to your generic method. The only additional thing which you need (admittedly it's a bit ugly, and we're thinking about removing it) is to add a FastTypeTag context bound as well. (This is necessary for the pickling framework to know what type it's trying to pickle, as it handles primitives differently, for example.)

This is what you'd need to do to provide generic pickling/unpickling methods:

Note that for the unbar method, you need to provide an Unpickler context-bound rather than a SPickler context-bound.

import scala.pickling._
import binary._

object Foo {
  def bar[T: SPickler: FastTypeTag](t: T) = t.pickle
  def unbar[T: Unpickler: FastTypeTag](bytes: Array[Byte]) = bytes.unpickle[T]
}

Testing this in the REPL, you get:

scala> Foo.bar(42)
res0: scala.pickling.binary.BinaryPickle =
BinaryPickle([0,0,0,9,115,99,97,108,97,46,73,110,116,0,0,0,42])

scala> Foo.unbar[Int](res0.value)
res1: Int = 42

When using the pickling library, where would a DPickler come into play? — Andy, Sep 12 '13 at 18:33

Andy · Answer 2 · 2013-09-10T18:33:46.983

Looking at the project, it seems you need either an scala.pickling.SPickler or a scala.pickling.DPickler (static and dynamic, respectively) in order to pickle a particular type.

The pickle methods are macros. I suspect that if you pickle with an SPickler, the macro will require the compile time type of your class to be known.

Thus, you may need to do something similar to:

object Foo {
  def bar(t: SomeClass1) = t.pickle
  def bar(t: SomeClass2) = t.pickle
  def bar(t: SomeClass3) = t.pickle
  // etc
}

Alternatively, a DPickler may do the trick. I suspect that you'll still have to write some custom pickling logic for your specific types.

Scala Pickling and type parameters

2 Answers2

Linked