A Combination of Lists, Case Classes and Tuples does not compile.

A simple combination of Lists, Cases Classes and Tuples does not compile. I see no reason, why it shouldn’t work. I minimized the example as far as i could. Note that it compiles when we remove one of the lists or change the tuple-type to a single Double or a Case Class.

  case class A(fills: List[B])
  case class B(stops: List[(Double,Double)])

  boopickle.Unpickle[A].fromBytes(null.asInstanceOf[ByteBuffer])

compileroutput with boopickle 1.0.0:

[error] C:\Users\florian.kirmaier\Dropbox\git\file.scala:32: Can
not materialize pickler for non-case class: scala.collection.immutable.List
[error]   boopickle.Unpickle[A].fromBytes(null.asInstanceOf[ByteBuffer])
[error]                     ^
[error] one error found
[error] (scalaServer/compile:compile) Compilation failed
[error] Total time: 59 s, completed Jun 23, 2015 11:52:35 AM

[XuJiawan]

Thanks to @cornerman and @ochrons ! There is a perfect solution for this problem now!! Just simply add boopickle-shapeless to your project!!

This is the code for the test above:

import boopickle.Default._
import java.nio.ByteBuffer

case class A(fills: List[B])
case class B(stops: List[(Double,Double)])

object Test {
  def deserializer() = {
    Unpickle[A].fromBytes(null.asInstanceOf[ByteBuffer])
  }
}

It’ll return the complication error:

Cannot materialize pickler for non-case class: List[com.try-boopickle.test.B]. If this is a collection, the error can refer to the class inside.

To solve it, add this to scala project:

"io.suzaku" %% "boopickle-shapeless" % "1.3.0"

And then simply change import boopickle.Default._ to import boopickle.shapeless.Default._!

More details in #89 and codes are here.

[steinybot]

I encountered this when doing some refactoring. All I did was to remove a type parameter from something so it was looking for Pickler[Thing[A]] instead of Pickler[Thing[_, A]]. My guess is that the existential type was somehow preventing the implicit divergence although I haven’t been able to replicate that.

The workaround in my case was to hide the iterablePickler and the mapPickler:

import boopickle.Default.{iterablePickler => _, mapPickler => _, _}

Then explicitly declare the collections I need:

  private implicit def setPickler[A: Pickler]: Pickler[Set[A]] = boopickle.Default.iterablePickler[A, Set]
  private implicit def listPickler[A: Pickler]: Pickler[List[A]] = boopickle.Default.iterablePickler[A, List]

---

I feel like there is more to this bug than just it being a “known limitation of the macro/implicit system”. I’ve never encountered so many weird cases where this bug pops up with other libraries. There are tons of tiny little things that either make this error appear or go away. It is definitely related to higher-kinded types but there are also some other oddities in there too.

You can see a bunch of things I found here https://gist.github.com/steinybot/e8710f6ff40379bf2d0f2767b5784fd4.