Constructing union type from an HList

UnionHList.scala

trait UnionOf[L <: HList] {
  type Mix
  type Out = not[Mix]
  type is[O] = UnionAux[L, O] 
}

/* Implicits for constructing union: */
object UnionOf {
  implicit val nil = 
    new UnionOf[HNil]   { type Mix = not[Nothing] }

  implicit def last[H, T <: HNil] = 
    new UnionOf[H :: T] { type Mix = not[H] }

  implicit def cons[H, T <: HList : shapeless.IsHCons](implicit m: UnionOf[T]) = 
    new UnionOf[H :: T] { type Mix = not[H] with m.Mix }
}

/* Stupid but necessary auxiliary stuff: */
trait  UnionAux[L <: HList, Out]
object UnionAux {
  implicit def uhlist[L <: HList](implicit u: UnionOf[L]) = new UnionAux[L, u.Out] {}
}


// Convenient aliases that will be put in scope by the package object
trait UnionHList {
  type not[A] = A => Nothing
  type SubtypeOf[U] = { type is[T] = not[not[T]] <:< U }
}

Simple example of usage:

trait ∈[E, L <: HList]
object ∈ {
  implicit def isin[L <: HList
    , U : UnionOf[L]#is
    , E : SubtypeOf[U]#is
    ] = new (E ∈ L) {}
}

implicitly[Int  ∈ (Int :: Char :: HNil)]
implicitly[Char ∈ (Int :: Char :: HNil)]

trait Foo
trait Boo extends Foo
implicitly[Boo ∈ (Int :: Foo :: Char :: HNil)]

/* Shouldn't compile: */
// implicitly[Boolean ∈ (Int :: Char :: String :: HNil)]
// implicitly[Nothing ∈ HNil]