Scala – 无形的HList到TupleN,其中元组形状不需要与HList形状完

import shapeless._,ops.hlist._,test._

object Demo {
  trait UniqueSelect[L <: HList,M <: HList] {
    def apply(l: L): M
  }

  object UniqueSelect {
    implicit def hnil[L <: HList]: UniqueSelect[L,HNil] =
      new UniqueSelect[L,HNil] {
        def apply(l: L): HNil = HNil
      }

    implicit def hcons[L <: HList,H,T <: HList,S <: HList]
      (implicit
        pt: Partition.Aux[L,H :: HNil,S],ust: UniqueSelect[S,T]
      ): UniqueSelect[L,H :: T] =
      new UniqueSelect[L,H :: T] {
        def apply(l: L): H :: T = {
          val (h :: HNil,s) = pt(l)
          h :: ust(s)
        }
      }
  }

  def toProductUniquely[P <: Product] = new ToProductUniquely[P]
  class ToProductUniquely[P <: Product] {
    def apply[L <: HList,M <: HList](l: L)
      (implicit gen: Generic.Aux[P,M],up: UniqueSelect[L,M]): P =
        gen.from(up(l))
  }

  val l = 23 :: (1,"wobble") :: "foo" :: HNil

  val t2 = toProductUniquely[(String,Int)](l)
  typed[(String,Int)](t2)
  assert(t2 == ("foo",23))

  illTyped("""
  toProductUniquely[(String,String)](l)
  """)

  illTyped("""
  toProductUniquely[Tuple1[(Int,String)]](l)
  """)
}

更新1

如果我们说我们有类型A和B<：A,那么对于所请求类型的子类型来满足选择的支持是非常简单的,则A :: B :: HNil中的A的选择是不明确的,因为两个元素都符合到A.这可以通过在以前的hcons定义中的证人添加一个SubtypeUnifier来完成,

import shapeless._,test._

object Demo extends App {
  trait UniqueSelect[L <: HList,M <: HList,S <: HList]
      (implicit
        su: SubtypeUnifier.Aux[L,pt: Partition.Aux[M,upt: UniqueSelect[S,s) = pt(su(l))
          h :: upt(s)
        }
      }
  }

  def toProductUniquely[P <: Product] = new ToProductUniquely[P]
  class ToProductUniquely[P <: Product] {
    def apply[L <: HList,M]): P =
        gen.from(up(l))
  }

  class A
  class B extends A
  class C

  val ac = new A :: new C :: HNil
  val bc = new B :: new C :: HNil
  val abc = new A :: new B :: new C :: HNil

  // Exact match
  val tac = toProductUniquely[(A,C)](ac)
  typed[(A,C)](tac)

  // Subtype
  val tbc = toProductUniquely[(A,C)](bc)
  typed[(A,C)](tbc)

  // Exact match again
  val tabc = toProductUniquely[(B,C)](abc)
  typed[(B,C)](tabc)

  // Ambiguous due to both elements conforming to A
  illTyped("""
  toProductUniquely[(A,C)](abc)
  """)
}

更新2

我们还可以适应一个统一的语义,它会优先于完全匹配,然后回到一个唯一的子类型,如更新的问题所述.我们通过组合上述两个解决方案的实例来实现：来自正常优先级的第一个实例的精确匹配实例和低优先级的子类型匹配实例,

import shapeless._,M <: HList] {
    def apply(l: L): M
  }

  object UniqueSelect extends UniqueSelect0 {
    implicit def hnil[L <: HList]: UniqueSelect[L,HNil] {
        def apply(l: L): HNil = HNil
      }

    implicit def hconsExact[L <: HList,s) = pt(l)
          h :: upt(s)
        }
      }
  }

  trait UniqueSelect0 {
    implicit def hconsSubtype[L <: HList,M]): P = gen.from(up(l))
  }

  trait A
  trait B extends A
  trait C extends A

  val a: A = new A {}
  val b: B = new B {}
  val c: C = new C {}

  // (b,5): subtypes match supertypes when there is no exact match
  toProductUniquely[(A,Int)](5 :: b :: HNil)

  // (a,5): only one exact match is available
  toProductUniquely[(A,Int)](5 :: b :: a :: HNil)

  // compile error: more than one exact match is available
  illTyped("""
  toProductUniquely[(A,Int)](5 :: a :: a :: HNil)
  """)

  // compile error: more than one inexact match is available
  illTyped("""
  toProductUniquely[(A,Int)](5 :: b :: c :: HNil)
  """)
}