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

I did it with Polys to learn something different, I think it would have actually been easier (but more verbose), to figure out with just custom typeclasses, but here you go:

  import shapeless._, ops.hlist._, poly._, labelled._

  trait Describe[A] {
    def apply(a: A): String
  }
  object Describe {
    def apply[A](a: A)(implicit ev: Describe[A]) = ev(a).dropRight(2)

    implicit def all[A](
        implicit f: Case.Aux[body.type, A :: HNil, String]): Describe[A] =
      new Describe[A] {
        def apply(a: A) = f.apply(a)
      }
    object body extends Compose(describer, flatten)

    object describer extends LowPrioDescriber {
      implicit def all[H <: HList](
          implicit fm: MapFolder[H, String, describer.type]) =
        at[H](x => fm(x, "", _ + _))
    }
    trait LowPrioDescriber extends Poly1 {
      implicit def base[K <: Symbol, V](implicit key: Witness.Aux[K]) =
        at[FieldType[K, V]](x => s"${key.value.name} = ${x.toString}, ")
    }

    object flatten extends LowPrioFlatten {
      implicit def hlists[H <: HList](
          implicit fm: Lazy[FlatMapper[flatten.type, H]]) =
        at[H](x => fm.value(x))

      implicit def kv[K, V, R](implicit gen: LabelledGeneric.Aux[V, R],
                               rec: Lazy[Case1[flatten.type, R]]) =
        at[FieldType[K, V]](x => rec.value(gen.to(x)))

      implicit def prods[A, R <: HList](
          implicit gen: LabelledGeneric.Aux[A, R],
          rec: Lazy[Case1[flatten.type, R]]) =
        at[A](x => rec.value(gen.to(x)))
    }
    trait LowPrioFlatten extends Poly1 {
      implicit def all[A] = at[A](x => x :: HNil)
    }
  }

example:

  case class Foo(a: String, b: Bar)
  case class Bar(c: Int, d: Baz)
  case class Baz(e: Long)

  val v = Foo("A", Bar(1, Baz(2)))

  def c = Describe(v)
 // res1: String = a = A, c = 1, e = 2

I'll go create a gist

David Hoyt

@davidhoyt

now to parse all of this to see if I can follow it...

Fabio Labella

@SystemFw

since someone else asked this several weeks ago, but I didn't have the time to fully solve it then

David Hoyt

@davidhoyt

this preserves the declaration order, right?

Fabio Labella

@SystemFw

what do you mean?

I tested it with the example you gave me

can't you see it? (gitter is weird sometimes)

one thing that I'm not too sure about

what happens with things like List

David Hoyt

@davidhoyt

e.g.:

case class Foo(a: String, b: Int, c: Bar)
case class Bar(d: Baz, e: Int)
case class Baz(f: Long, g: String)

val v = Foo("A", 1, Bar(Baz(2, "G"), 3))

// a = A b = 1 f = 2 g = G e = 3

I actually don't care about preserving order, but bonus points if it does. I am inclined to think that it preserves it.

Fabio Labella

@SystemFw

res1: String = a = A, b = 1, f = 2, g = G, e = 3
that's the result

however, describer probably needs some modification, it doesn't compile if your case classes have Lists in them

but the basic idea is there

mm, no, there'a problem

but it's a problem with the whole idea, not with the implementation

what do you want the behaviour to be if your classes contain things like List Option, and in general, data types with alternatives?

David Hoyt

@davidhoyt

@SystemFw I would derive a type class for it. e.g.: https://scalafiddle.io/sf/8e8Kbup/0

@SystemFw in that fiddle i try to do just that but it doesn't work

Fabio Labella

@SystemFw

but what do you want the result to be? there's a very easy way to have it print "b = List(1,2)" in that case

David Hoyt

@davidhoyt

I don't think I'm following then -- I want the result to be whatever the type class decides

Fabio Labella

@SystemFw

now I'm not following :)

the basic problem is this: how do you distinguish between a Baz and a List?

also note that my solution was merely for the example at the beginning, if you want different strategies for unpacking different things you are probably better off moving away from the Poly towards a custom type class (even though you get to keep, with small adaptations, most of the code in the instances)

the reason for that is my approach first flattens, then describes

Fabio Labella

@SystemFw

(btw, to have it print List(1,2) just add <: HListto the R type parameter in kv)

if you want Lists to be printed differently, e.g. 1..2, add an instance to describer

David Hoyt

@davidhoyt

@SystemFw please see my fiddle here: https://scalafiddle.io/sf/8e8Kbup/1
it is not picking up and using forTraversable()

@SystemFw so I do want Lists to be printed differently which is why I added an implicit def to construct a type class for List[Int]. it should display lists as [1,2]

Fabio Labella

@SystemFw

the way my approach works, you don't write down any more instances for Describe

because Describe is not being resolved recursively

(you could do it that way, but you need to change my code first)

I can tweak it to accommodate your use case I think

so, iterables should be [1,2,3] and so on right? or [1] if they have one element

David Hoyt

@davidhoyt

@SystemFw it's supposed to be a type class so I could change the output by changing which implementation is implicitly available. my fiddle gives my default implementation.

Fabio Labella

@SystemFw

right (just a thing, if you have multiple implementations for the same type, it's not technically a type class)

anyway what you want can be done with my approach

but it would probably be cleaner if you just used a custom, recursive typeclass instead of Polys

@davidhoyt I don't have any more time to write code I'm afraid, but I can tell you how to do it :)

first, add add <: HList to the R type parameter in kv

second, you need to modify base in LowPrioDescriber to take an implicit f: Format[V]where Format is a typeclass that converts types to String

then you replace .toString with f(x: V)

Fabio Labella

@SystemFw

add implementations of Format for Lists to get what you want. Add a lower priority implementation for anything that just uses toString to get the default behaviour for other values

if Format sounds similar to Describe, it's because it is! Hence my point about all this being probably better if rewritten from scratch as a recursive typeclass

However, you can reuse my code to implement what you wanted in your original question, i.e. how to flatten arbitrarily nested case classes, while preserving their LabelledGeneric#Repr type to get access to the field names later

David Hoyt

@davidhoyt

@SystemFw did it -- appears to be working thanks :) looks like it doesn't work on HLists themselves though. here's the latest: https://scalafiddle.io/sf/8e8Kbup/4

i guess it doesn't work on HList since it can't create LabelledGeneric for the example I tried. makes sense. :)

Where communities thrive

People

Repo info

Activity