Releases: scala/pickling
0.10.1
Improvements
Fixes
- Fixes pickling of Java objects. See below
- Fixes unpickling of sealed trait in
Array
. #294 by @jsuereth - Fixes unpickling of
val
whose implementation accesses a field. #328 by @phaller
Java Pickling workaround
Scala Pickling by default uses compile-time type information
to automatically generate a pickler for a given type.
For Java types, Pickling tries to guess the list of fields,
and it often guesses incorrectly. #60, #263
Pickling 0.10.1 adds a workaround by stopping to
compile when it detects an empty pickler. #295 by @eed3si9n
0.10.0
This is the first stable release of Scala Pickling, an automatic serialization framework made for Scala.
It's fast, boilerplate-free, and allows users to easily swap in/out different serialization formats (such as binary, or JSON). We will retain binary compatibility throughout the 0.10.x series. We'll also keep format compatibility during 0.10.x.
Pickling in a nutshell
To pickle a value, let's say Person("foo", 20)
, you need two things.
A pickler combinator for the given type Person
, and a pickle format.
The Pickler[A]
is responsible for breaking A
down to abstract entries, fields, and collections.
It's called a combinator, because complex pickler combinators can be composed from primitive picklers.
The PickleFormat
turns the abstract notions like fields into binary or text representation.
Defaults mode
Here's a basic usage using Defaults
mode.
scala> import scala.pickling.Defaults._, scala.pickling.json._
scala> case class Person(name: String, age: Int)
scala> val pkl = Person("foo", 20).pickle
pkl: pickling.json.pickleFormat.PickleType =
JSONPickle({
"$type": "Person",
"name": "foo",
"age": 20
})
scala> val person = pkl.unpickle[Person]
person: Person = Person(foo,20)
The Defaults
mode automatically derives Pickler[Person]
from the primitive picklers at compile-time!
Because the code is statically generated, we can inline the string manipulations and make it fast.
(Faster than Java serialization or Kryo, which also does not require schema)
Note, because Pickler[A]
is a typeclass, Pickling can be retrofitted to Person
without modifying the class to inherit Serializable or something like that.
DIY protocol stack
Pickling 0.10.0 offers picklers, ops, and formats as traits, which can be
stacked together, so third-party libraries can provide custom modes.
Suppose you only want to pickle primitive types and Apple
, and don't want to automatically
derive pickler combinators. Here's a custom mode:
scala> case class Apple(kind: String)
scala> val appleProtocol = {
import scala.pickling._
new pickler.PrimitivePicklers with pickler.RefPicklers
with json.JsonFormats {
// Manually generate pickler for Apple
implicit val applePickler = PicklerUnpickler.generate[Apple]
// Don't fall back to runtime picklers
implicit val so = static.StaticOnly
// Provide custom functions
def toJsonString[A: Pickler](a: A): String =
functions.pickle(a).value
def fromJsonString[A: Unpickler](s: String): A =
functions.unpickle[A](json.JSONPickle(s))
}
}
scala> import appleProtocol._
scala> toJsonString(Apple("honeycrisp"))
res0: String =
{
"$type": "Apple",
"kind": "honeycrisp"
}
For more details see Pickling.