milessabin/shapeless

Hi all, I have a code for getting string from string pool an compile-time:

    final case class Foo(int: Int, long: Long)

    trait Name {
      type R <: String
      val name: R

      override def toString: String = name
    }

    trait NameR[S <: String] extends Name {
      type R = S
      val name: S
    }

    object Name {
      def apply(name0: String): NameR[name0.type] = new NameR[name0.type] {
        override type R = name0.type
        override val name: name0.type = name0
      }
    }

    class Holder[H <: HList](hlist: H) {

      def add(name: String): Holder[NameR[name.type] :: H] = new Holder[NameR[name.type] :: H](Name(name) :: hlist)

      def select(name: String)(implicit selector: NameSelector[H, name.type]): String = name
    }

    object Holder extends Holder(HNil: HNil)

    @implicitNotFound("Could not find field ${S} in ${L}")
    trait NameSelector[L <: HList, S <: String] {
      def apply(l: L): NameR[S]
    }

    object NameSelector {

      def apply[L <: HList](name: String, l: L)(implicit selector: NameSelector[L, name.type]): NameR[name.type] =
        selector.apply(l)

      def apply[L <: HList, S <: String](implicit selector: NameSelector[L, S]): NameSelector[L, S] = selector

      implicit def select[S <: String, T <: HList]: NameSelector[NameR[S] :: T, S] =
        (l: NameR[S] :: T) => l.head

      implicit def recurse[S1 <: String, S <: String, T <: HList](implicit st: NameSelector[T, S]): NameSelector[NameR[S1] :: T, S] =
        (l: NameR[S1] :: T) => st.apply(l.tail)
    }

I can use it like:

    val fields = Holder.add("int").add("long")
    fields.select("int")

Now I want to implement the same thing above but for case class fields which should automatically added into my string pool. Smth like this:

 val lbl = LabelledGeneric[Foo]
 val keys = Keys[lbl.Repr].apply

 val fields = keys.foldLeft(Holder)(???)
  fields.select("int")

but I don't know how to implement poly fold function
Can somebody help me?