shapeless: Generic programming for Scala | This room deprecated in favour of #shapeless on the Typelevel Discord: https://discord.gg/bSQBZA3Ced
I’ll share as well if I get my indirection wired up
object Module {
import shapeless._
sealed trait Decode[A] {
def decode(s: String): Option[A]
}
object Decode {
def dummy[A]: Decode[A] = new Decode[A] {
def decode(s: String) = Option.empty[A]
}
def apply[A](implicit decoder: Decode[A]): Decode[A] =
decoder
implicit def strings: Decode[String] = dummy[String]
implicit def bools: Decode[Boolean] = dummy[Boolean]
implicit def ints: Decode[Int] = dummy[Int]
implicit def hnil: Decode[HNil] = dummy[HNil]
implicit def hcons[H: Decode, T <: HList: Decode]: Decode[H :: T] =
dummy[H :: T]
implicit def cnil: Decode[CNil] = dummy[CNil]
implicit def ccons[H: Decode, T <: Coproduct: Decode]: Decode[H :+: T] =
dummy[H :+: T]
}
trait DeriveDecoder[F] {
implicit def generics[A <: F, R](implicit gen: Generic.Aux[A, R],
decoder: Decode[R]): Decode[A] = Decode.dummy[A]
}
}
sealed trait A
case class B(s: String, i: Int) extends A
case class C(b: Boolean) extends A
object A extends Module.DeriveDecoder[A]
sealed trait A1
case class B1(s: String, i: Int) extends A1
case class C1(b: Boolean) extends A1
object Test {
import shapeless.test._
val a = Module.Decode[A]
val b = illTyped("Module.Decode[A1]")
// code compiles
}
Note the zero imports required at call site
this would probably be my preferred solution actually
like this
object Module {
import shapeless._
sealed trait Decode[A] {
def decode(s: String): Option[A]
}
object Decode {
def dummy[A]: Decode[A] = new Decode[A] {
def decode(s: String) = Option.empty[A]
}
def apply[A](implicit decoder: Decode[A]): Decode[A] =
decoder
implicit def strings: Decode[String] = dummy[String]
implicit def bools: Decode[Boolean] = dummy[Boolean]
implicit def ints: Decode[Int] = dummy[Int]
implicit def hnil: Decode[HNil] = dummy[HNil]
implicit def hcons[H: Decode, T <: HList: Decode]: Decode[H :: T] =
dummy[H :: T]
implicit def cnil: Decode[CNil] = dummy[CNil]
implicit def ccons[H: Decode, T <: Coproduct: Decode]: Decode[H :+: T] =
dummy[H :+: T]
implicit def generics[A, R](implicit gen: Generic.Aux[A, R],
decoder: Decode[R], opt: OptIn[A]): Decode[A] = Decode.dummy[A]
}
sealed trait OptIn[A]
object OptIn {
def instance[A]: OptIn[A] = new OptIn[A] {}
}
trait DeriveDecoder[F] {
implicit def optIn[A <: F] = OptIn.instance[A]
}
}
sealed trait A
case class B(s: String, i: Int) extends A
case class C(b: Boolean) extends A
object A extends Module.DeriveDecoder[A]
sealed trait A1
case class B1(s: String, i: Int) extends A1
case class C1(b: Boolean) extends A1
object Test {
import shapeless.test._
val a = Module.Decode[A]
val b = illTyped("Module.Decode[A1]")
// code compiles
}
i really only need to know if I'm nested or not. this is for automatic type class derivation btw.
generally speaking, I want to take nested case classes and spit out a flattened list of field=value. e.g.:
case class Foo(a: String, b: Bar)
case class Bar(c: Int, d: Baz)
case class Baz(e: Long)
val instance = Foo("A", Bar(1, Baz(2)))
val flattened: String = ??? // Should be "a=A c=1 e=2"
@davidhoyt look into HList ops - there’s an example for this: https://github.com/milessabin/shapeless/blob/master/examples/src/main/scala/shapeless/examples/flatten.scala
(operates on tuples but hlist is isomorphic to tuple)
is not flattening, that's easy
actually, I take it back. Flattening HLists is easy
flattening Products has additional difficulties, let me give it a try
@aroberts how are you encoding the coproduct?
I mean the mapping Coproduct => Index
what is it?
trait MsgpackIndexed[A] extends Msgpack[A] {
private val si = Serialize[Int]
val defaultIndex = 0
def pack(v: A) = packIndexed(defaultIndex, v).flatMap((packWithIndex _).tupled)
def unpack(v: MessagePack) = v match {
case MFixArray(Vector(i, m)) => si.unpack(i).flatMap(unpackIndexed(_, m))
case _ => Attempt.failure(Err(s"Couldn't unpack indexed messagepack from $v"))
}
def packIndexed(index: Int, v: A): Attempt[(Int, MessagePack)]
def unpackIndexed(index: Int, v: MessagePack): Attempt[A]
private def packWithIndex(index: Int, payload: MessagePack): Attempt[MessagePack] =
si.pack(index).map(packed => MFixArray(Vector(packed, payload)))
}
nope, that's not what I mean :)
but rather, given an ADT coproduct, how does the numbering work?
implicit val serializeCNil: MsgpackIndexed[CNil] = new MsgpackIndexed[CNil] {
def packIndexed(index: Int, v: CNil) = Attempt.failure(Err(s"CNil can't be packed: $v"))
def unpackIndexed(index: Int, v: MessagePack) = Attempt.failure(Err(s"CNil can't be unpacked: $v"))
}
implicit def serializeCCons[H, T <: Coproduct](implicit
hSer: Msgpack[H],
tSer: MsgpackIndexed[T]
): MsgpackIndexed[H :+: T] = new MsgpackIndexed[H :+: T] {
def packIndexed(index: Int, v: H :+: T) = v match {
case Inl(h) => hSer.pack(h).map((index, _))
case Inr(t) => tSer.packIndexed(index + 1, t)
}
def unpackIndexed(index: Int, v: MessagePack) = index match {
case 0 => hSer.unpack(v).map(Inl(_))
case n => tSer.unpackIndexed(n - 1, v).map(Inr(_))
}
}
Is that what you mean? it’s basically a count of how many
Inr cases are processed before an Inl instance is encountered
what's the problem with it?
auto derivation after invocation
(sorry, I thought you were still stuck on the above, but the approach I was going to suggest is what you already have :) )
mm actually wait
it should "derive Msgpack instances for sealed ADTs" in {
implicit val childSer: Msgpack[Family.Child] = deriveMsgpack
implicit val parentSer: Msgpack[Family.Parent] = deriveMsgpack
implicit val ser: Msgpack[Family] = deriveMsgpack
}
but with them in place, it compiles just fine