Add KeyDecoder for typelevel key modifying

modules/core/src/main/scala/mess/KeyDecoder.scala

@@ -0,0 +1,12 @@
+package mess
+
+trait KeyDecoder[S <: Symbol] {
+  def apply(a: S): String
+}
+
+object KeyDecoder {
+
+  implicit def decodeSymbolKey[S <: Symbol]: KeyDecoder[S] = new KeyDecoder[S] {
+    def apply(m: S): String = m.name
+  }
+}

modules/core/src/main/scala/mess/codec/generic/DerivedDecoder.scala

@@ -21,14 +21,16 @@ private[mess] trait LowPriorityDerivedDecoder {
   implicit final def decodeLabelledHList[K <: Symbol, H, T <: HList](
       implicit
       witK: Witness.Aux[K],
+      decodeK: mess.KeyDecoder[K],
       decodeH: Decoder[H],
       decodeT: DerivedDecoder[T]): DerivedDecoder[FieldType[K, H] :: T] =
     new DerivedDecoder[FieldType[K, H] :: T] {
       def apply(m: MsgPack): Decoder.Result[FieldType[K, H] :: T] = m match {
         case MsgPack.MMap(a) =>
           decodeT(m) match {
             case Right(t) =>
-              val v = a.getOrElse(MsgPack.MString(witK.value.name), MsgPack.MNil)
+              val key = decodeK(witK.value)
+              val v   = a.getOrElse(MsgPack.MString(key), MsgPack.MNil)
               decodeH(v) match {
                 case Right(h) => Right(field[K](h) :: t)
                 case Left(e)  => Left(e)

modules/examples/src/main/scala/com/github/tkrs/example/Main.scala

@@ -4,9 +4,15 @@ import mess._
 import mess.ast.MsgPack
 import mess.codec.generic._
 import org.msgpack.core.MessagePack._
+import shapeless.Witness
 
 final case class Foo(age: Int, name: String)
 object Foo {
+  type Name = Witness.`'name`.T
+
+  implicit val encodeName: Encoder[Name]    = (n: Name) => MsgPack.fromString(n.name.toUpperCase())
+  implicit val decodeName: KeyDecoder[Name] = (s: Name) => s.name.toUpperCase()
+
   implicit val encodeFoo: Encoder[Foo] = derivedEncoder[Foo]
   implicit val decodeFoo: Decoder[Foo] = derivedDecoder[Foo]
 }
@@ -21,9 +27,15 @@ object Main extends App {
 
   val bar = Bar(Foo(2305, "Archimedes") :: Foo(411, "Johannes Kepler") :: Nil)
 
-  val packed = MsgPack.pack(Encoder[Bar].apply(bar), DEFAULT_PACKER_CONFIG)
+  val encoded = Encoder[Bar].apply(bar)
+  println(encoded)
+
+  val packed = MsgPack.pack(encoded, DEFAULT_PACKER_CONFIG)
+
+  val unpacked = MsgPack.unpack(packed, DEFAULT_UNPACKER_CONFIG)
+  println(unpacked)
 
-  val unpacked = Decoder[Bar].apply(MsgPack.unpack(packed, DEFAULT_UNPACKER_CONFIG))
+  val decoded = Decoder[Bar].apply(unpacked)
 
-  assert(Right(bar) == unpacked)
+  assert(Right(bar) == decoded)
 }