trait Lang {
  def name: String
}

object Lang {
  trait En extends Lang { def name = "en"}
  implicit object En extends En
  trait Fr extends Lang { def name = "fr"}
  implicit object Fr extends Fr
  trait De extends Lang { def name = "de"}
  implicit object De extends De
}

import Lang._
import shapeless._
import shapeless.LUBConstraint.<<:
import shapeless.ops.hlist.{Selector, ToTraversable}
import shapeless.ops.hlist.Prepend._
import shapeless.ops.hlist.Prepend
import shapeless.ops.hlist.ToTraversable._

import scala.annotation.implicitNotFound

object I18n {
  class `I18n.apply`[L <: HList : <<:[Lang]#λ](){
    def apply[T](value: T)(implicit l: L, toTraversableAux : ToTraversable.Aux[L, List, Lang])  =
      new I18n[T, L](l.toList.map(_ -> value).toMap, l)
  }

  def apply[L <: HList : <<:[Lang]#λ] = new `I18n.apply`[L]()
}

class I18n[+T, L <: HList : <<:[Lang]#λ] private (private val inner: Map[Lang, T], private val l: L) {

  def apply[U <: Lang](implicit selector : Selector[L, U], u: U) : T = inner(u)

  def & [TT >: T, LL <: HList : <<:[Lang]#λ, LLL<: HList](that: I18n[TT, LL])(implicit p: Prepend.Aux[LL, L, LLL]): I18n[TT, LLL]
   = {
    implicit val _: <<:[Lang]#λ[LLL] = new LUBConstraint[LLL, Lang] {}
    new I18n[TT, LLL](inner ++ that.inner, p.apply(that.l, this.l))
  }
}

object Ex extends App {
  implicit val baseCase = HNil
  implicit def recurse[Head, Tail <: HList](implicit h: Head, t: Tail) = h :: t

  val i = I18n[En :: Fr :: HNil].apply("hello")

  val j = i & I18n[De :: HNil].apply("asdfasdf")

  println(i[En])
  //  i[De] // DOES NOT COMPILE :-)
  println(j[En])
  println(j[De])

}