You don’t need any 3rd party library to do this: sealed trait MyTrait case object SubClass1 extends MyTrait case object SubClass2 extends MyTrait import scala.reflect.runtime.{universe => ru} val tpe = ru.typeOf[MyTrait] val clazz = tpe.typeSymbol.asClass // if you want to ensure the type is a sealed trait, // then you can use clazz.isSealed and clazz.isTrait … Read more
Imagine a typeclass for getting the last element of any tuple. trait Last[A] { type B def last(a: A): B } object Last { type Aux[A,B0] = Last[A] { type B = B0 } implicit def tuple1Last[A]: Aux[Tuple1[A],A] = new Last[Tuple1[A]] { type B = A def last(a: Tuple1[A]) = a._1 } implicit def tuple2Last[A,C]: … Read more
Here’s an off-the-cuff, mostly untested solution. First for the type class: import shapeless._, labelled.{ FieldType, field } trait FromMap[L <: HList] { def apply(m: Map[String, Any]): Option[L] } And then the instances: trait LowPriorityFromMap { implicit def hconsFromMap1[K <: Symbol, V, T <: HList](implicit witness: Witness.Aux[K], typeable: Typeable[V], fromMapT: Lazy[FromMap[T]] ): FromMap[FieldType[K, V] :: T] … Read more
I will attempt one myself. I will gladly accept a better answer from Travis Brown or Miles Sabin. Nat can currently not be used to represent large numbers In the current implementation of Nat, the value corresponds to the number of nested shapeless.Succ[] types: scala> Nat(3) res10: shapeless.Succ[shapeless.Succ[shapeless.Succ[shapeless._0]]] = Succ() So to represent the number … Read more
There’s an easy fix: just define your function as an object instead of a val: object f extends (({ type O2[+A] = (Option[A], Option[A]) })#O2 ~> Option) { def apply[A](x: (Option[A], Option[A])): Option[A] = x._1 orElse x._2 } (Note that I’ve named the function f instead of mapper to avoid confusion with the mapper implicit … Read more
Any time you want to perform an operation like flatMap on an HList whose type isn’t statically known, you’ll need to provide evidence (in the form of an implicit parameter) that the operation is actually available for that type. This is why the compiler is complaining about missing FlatMapper instances—it doesn’t know how to flatMap(identity) … Read more
This works as written as of the most recent shapeless 2.1.0-SNAPSHOT.
Addressing questions one to three: one of the main applications for HLists is abstracting over arity. Arity is typically statically known at any given use site of an abstraction, but varies from site to site. Take this, from shapeless’s examples, def flatten[T <: Product, L <: HList](t : T) (implicit hl : HListerAux[T, L], flatten … Read more
In general, the element types of a tuple aren’t the same, so map doesn’t make sense. You can define a function to handle the special case, though: scala> def map[A, B](as: (A, A))(f: A => B) = as match { case (a1, a2) => (f(a1), f(a2)) } map: [A,B](as: (A, A))(f: (A) => B)(B, B) … Read more
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-dependent types. These allow a type to depend on a selector path through an object- (ie. value-) … Read more