milessabin/shapeless

shapeless: Generic programming for Scala | This room deprecated in favour of #shapeless on the Typelevel Discord: https://discord.gg/bSQBZA3Ced

Fabio Labella

@SystemFw

why, you won't need imports I don't think

maybe you can even have a trait to mixin the implicit instance into the companion object at call site:

case class Foo
object Foo extends Summoner[Foo]

where Foo[A] has an implicit deriveMsgPack for A

I'll need to try it out to see if it works

maybe precedence will screw it up, I don't know. It feels like it should work though.

Andrew Roberts

@aroberts

I don’t think my command of implicits is strong enough to follow your approach all the way through

Fabio Labella

@SystemFw

right, the first step is to get it to work by putting everything into the companion object of Codec

Andrew Roberts

@aroberts

yep

Fabio Labella

@SystemFw

with deriveMsgPack as implicit

then move the implicit deriveMsgPack into the companion object of an example case class and see if it still works

I'm not 100% sure of the precedence

but if it does work

then you can try having a trait just to declare the implicit for your users

again, I'll need to double check

actually, I'll try and write an example with an empty typeclass to see if my approach makes sense or not (it might not)

might have some time later on tonight, perhaps

I'll ping you if I manage :)

Andrew Roberts

@aroberts

ok, awesome :)

I’ll share as well if I get my indirection wired up

Fabio Labella

@SystemFw

:+1:

Fabio Labella

@SystemFw

@aroberts This is what I have in mind

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

Fabio Labella

@SystemFw

another way of doing it would be to put generics back into Decode, but add a dummy typeclass to its implicit arguments, and then have DeriveDecoder[A] derive an instance of said dummy typeclass for all subtypes of A

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
}

David Hoyt

@davidhoyt

hello -- looking for a way to get the depth of nested HLists. e.g.: String :: (Int :: (Long :: HNil) :: HNil) :: HNil. any recommended approach?

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"

David Hoyt

@davidhoyt

I've started by looking at LabelledGeneric and can iterate over fields and values, but I haven't thus far worked out how to successfully determine if I'm nested

Andrew Roberts

@aroberts

@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)

Fabio Labella

@SystemFw

@davidhoyt the problem with what you want to do

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

Andrew Roberts

@aroberts

@SystemFw I think I took the same approach, just organized a little bit differently

Fabio Labella

@SystemFw

:+1:

Andrew Roberts

@aroberts

the only think I’m missing is deriving the freaking cases from within the coproduct derived codec

Fabio Labella

@SystemFw

what I like about OptIn is that I can envision it being expanded with options to customise the derivation, using the same scheme

@aroberts how are you encoding the coproduct?

I mean the mapping Coproduct => Index

what is it?

Andrew Roberts

@aroberts

I created a special-case encoding instance that’s index-aware

Fabio Labella

@SystemFw

yeah that's not what I mean

Andrew Roberts

@aroberts

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)))
}

Fabio Labella

@SystemFw

ah ok wait

nope, that's not what I mean :)

but rather, given an ADT coproduct, how does the numbering work?

Where communities thrive

People

Repo info

Activity