shapeless

The question here asks about mapping a case class to a Map[String,Any]. I was wondering what would be the other way around, converting Map[String,Any] to a case class. Given the following map: val mp = Map("name" -> "Tom", "address" -> Map("street" -> "Jefferson st", "zip" -> 10000)) Convert it to a case class of Person : case class Person(name:String, address:Address) case class Address(street:String, zip:Int) val p = Person("Tom", Address("Jefferson st", 10000)) with something like this: val newP = mp.asCC[Person] assert(newP.get == p) How should I do that with Shapeless. Travis Brown Here's

I'm pretty sure I'm missing something here, since I'm pretty new to Shapeless and I'm learning, but when is the Aux technique actually required ? I see that it is used to expose a type statement by raising it up into the signature of another "companion" type definition. trait F[A] { type R; def value: R } object F { type Aux[A,RR] = F[A] { type R = RR } } but isn't this nearly equivalent to just putting R in the type signature of F ? trait F[A,R] { def value: R } implicit def fint = new F[Int,Long] { val value = 1L } implicit def ffloat = new F[Float,Double] { val value = 2.0D } def f[T,R](t:T

There are path dependent types and I think it is possible to express almost all the features of such languages as Epigram or Agda in Scala, but I'm wondering why Scala does not support this more explicitly like it does very nicely in other areas (say, DSLs) ? Anything I'm missing like "it is not necessary" ? Miles Sabin Syntactic convenience aside, the combination of singleton types, path-dependent types and implicit values means that Scala has surprisingly good support for dependent typing, as I've tried to demonstrate in shapeless . Scala's intrinsic support for dependent types is via path

I was trying to solve this problem with shapeless. However I am for some reason unable to map on the HList . I'll let the code speak for itself. import shapeless._ import HList._ case class Foo(a: Option[Int], b: Option[Int]) val a = Foo(Some(3), None) val b = Foo(Some(22), Some(1)) implicit val fooIso = HListIso(Foo.apply _, Foo.unapply _) val mapper = new (({ type O2[+A] = (Option[A], Option[A]) })#O2 ~> Option) { def apply[A](x: (Option[A], Option[A])): Option[A] = x._1.orElse(x._2) } fooIso.fromHList(fooIso.toHList(a).zip(fooIso.toHList(b)).map(mapper)) Error message is: <console>:55:

I am trying to solve this question using Shapeless, in summary it's about converting a nested case class to Map[String,Any], here is the example: case class Person(name:String, address:Address) case class Address(street:String, zip:Int) val p = Person("Tom", Address("Jefferson st", 10000)) It wants to convert p to following: Map("name" -> "Tom", "address" -> Map("street" -> "Jefferson st", "zip" -> 10000)) I am trying to do it using Shapeless LabelledGeneric , here is what I for so far: import shapeless._ import record._, syntax.singleton._ import ops.record._ import shapeless.ops.record._ def

Suppose I've got a type class that proves that all the types in a Shapeless coproduct are singleton types: import shapeless._ trait AllSingletons[A, C <: Coproduct] { def values: List[A] } object AllSingletons { implicit def cnilSingletons[A]: AllSingletons[A, CNil] = new AllSingletons[A, CNil] { def values = Nil } implicit def coproductSingletons[A, H <: A, T <: Coproduct](implicit tsc: AllSingletons[A, T], witness: Witness.Aux[H] ): AllSingletons[A, H :+: T] = new AllSingletons[A, H :+: T] { def values = witness.value :: tsc.values } } We can show that it works with a simple ADT: sealed

I am really interested in finding out where the differences are, and more generally, to identify canonical use cases where HLists cannot be used (or rather, don't yield any benefits over regular lists). (I am aware that there are 22 (I believe) TupleN in Scala, whereas one only needs a single HList, but that is not the kind of conceptual difference I am interested in.) I've marked a couple of questions in the text below. It might not actually be necessary to answer them, they are more meant to point out things that are unclear to me, and to guide the discussion in certain directions.

'map' preserves the number of elements, so using it on a Tuple seems sensible. My attempts so far: scala> (3,4).map(_*2) error: value map is not a member of (Int, Int) (3,4).map(_*2) ^ scala> (3,4).productIterator.map(_*2) error: value * is not a member of Any (3,4).productIterator.map(_*2) ^ scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2) res4: Iterator[Int] = non-empty iterator scala> (3,4).productIterator.map(_.asInstanceOf[Int]*2).toList res5: List[Int] = List(6, 8) It looks quite painful... And I haven't even begun to try to convert it back to a tuple. Am I doing it wrong? Could