Konvertieren HList Karte mit stupless

Question

Ich beginne mit der Arbeit mit formlosen, und als Beweis des Konzepts, ich definierte Funktion für Hlist konvertieren, um Karte, aber etwas schief gelaufen ist, können Sie mir bitte helfen?

object bar extends Poly1 { 
    implicit def caseTuple[T, U](implicit st: Case.Aux[T, Map[String, Any]], su: Case.Aux[U, Map[String, Any]]) = 
    at[(T, U)](t => { 
    Map(s"${t._1}" -> t._2) 
    }) 
} 

object foo extends Poly2 { 
implicit def default[T](implicit st: bar.Case.Aux[T, Map[String, Any]]) = 
    at[Map[String, Any], T] { (acc, t) => 
    acC++ bar(t) 
    } 
} 

val h = ("k1", 1) :: ("k2", "foo") :: HNil 
println(h.foldLeft(Map.empty[String, Any])(foo)) 

Aber ich habe Fehler: could not find implicit value for parameter folder: shapeless.ops.hlist.LeftFolder[shapeless.::[(String, Int),shapeless.::[(String, String),shapeless.HNil]],scala.collection.immutable.Map[String,Any],Main.foo.type] [error] println(h.foldLeft(Map.empty[String, Any])(foo))

Answer 1

1. Da Sie nicht über den Wert Typ egal, die Sie nicht spezielle polymorphe Funktion für den Werttyp benötigen.

2. Wenn Sie nur auf .toString verlassen, Sie brauchen keine Poly1 so dass das obige Beispiel wie folgt neu geschrieben werden:

object foo1 extends Poly2 { 
    implicit def default[K, V] = 
    at[Map[String, Any], (K, V)] { case (acc, (k, v)) => 
     acc + (k.toString -> v) 
    } 
} 

val h = ("k1", 1) :: ("k2", "foo") :: (true, "TRUE") :: HNil 
println(h.foldLeft(Map.empty[String, Any])(foo1)) 
// Map(k1 -> 1, k2 -> foo, true -> TRUE) 

3. Wenn Sie an der Schlüsselposition mehrere Typen haben, müssen Sie sie in Zeichenfolgen konvertieren. Es kann sein Poly1 oder jede Art Klasse wie scalaz.Show oder cats.Show, die A => String bieten.

object bar2 extends Poly1 { 
    implicit val stringCase = at[String](identity) 
    implicit val symbolCase = at[Symbol](_.name) 
    implicit def integralCase[A: Integral] = at[A](_.toString) 
    implicit def fractionalCase[A: Fractional] = at[A](_ formatted "%.2f") 
} 

object foo2 extends Poly2 { 
    implicit def default[K, V](implicit bk: bar2.Case.Aux[K, String]) = 
    at[Map[String, Any], (K, V)] { case (acc, (k, v)) => 
     acc + (bk(k) -> v) 
    } 
} 

val h2 = ("k1", 1) :: ("k2", "foo") :: ('k3, true) :: (12.3456, 'frac) :: HNil 
println(h2.foldLeft(Map.empty[String, Any])(foo2)) 
// Map(k1 -> 1, k2 -> foo, k3 -> true, 12.35 -> 'frac) 

Sie können das gleiche tun, anstatt Any einen anderen Schlüsseltyp zu haben.