在scala中，如何使类型类适用于Aux模式？ - 第2部分

这是以下问题的后续问题：在scala中，如何使类型类适用于Aux模式？ https://stackoverflow.com/questions/65838535/in-scala-how-to-make-type-class-working-for-aux-pattern

考虑以下示例：

  trait Base {

    type Out
    def v: Out
  }

  object Base {

    type Aux[T] = Base { type Out = T }
    type Lt[T] = Base { type Out <: T }

    class ForH() extends Base {

      final type Out = HNil

      override def v: Out = HNil
    }

    object ForH extends ForH
  }

  trait TypeClasses {

    class TypeClass[B]

    def summon[B](b: B)(implicit ev: TypeClass[B]): TypeClass[B] = ev
  }

  object T1 extends TypeClasses {

    implicit def t1: TypeClass[Base.Aux[HNil]] = new TypeClass[Base.Aux[HNil]]

    implicit def t2: TypeClass[Int] = new TypeClass[Int]
  }

  object T2 extends TypeClasses {

    implicit def t1[T <: Base.Aux[HNil]]: TypeClass[T] = new TypeClass[T]
  }

  object T3 extends TypeClasses {

    implicit def t1[
        H <: HList,
        T <: Base.Lt[H]
    ]: TypeClass[T] = new TypeClass[T] {

      type HH = H
    }
  }

  object T4 extends TypeClasses {

    implicit def t1[
        H <: HList,
        T <: Base.Aux[H]
    ]: TypeClass[T] = new TypeClass[T] {

      type HH = H
    }
  }

  it("No Aux") {

    val v = 2

    T1.summon(v) // works
  }

  it("Aux1") {

    val v = new Base.ForH()

    T1.summon(v) // oops
    T1.summon(Base.ForH) // oops

    val v2 = new Base.ForH(): Base.Aux[HNil]
    T1.summon(v2) // works!
  }

  it("Aux2") {

    val v = new Base.ForH()

    T2.summon(v) // works
    T2.summon(Base.ForH) // works

    val v2 = new Base.ForH(): Base.Aux[HNil]
    T2.summon(v2) // works
  }

  it("Aux3") {

    val v = new Base.ForH()

    T3.summon(v) // oops
    T3.summon(Base.ForH) // oops

    val v2 = new Base.ForH(): Base.Aux[HNil]
    T3.summon(v2) // oops
  }

  it("Aux4") {

    val v = new Base.ForH()

    T4.summon(v) // oops
    T4.summon(Base.ForH) // oops

    val v2 = new Base.ForH(): Base.Aux[HNil]
    T4.summon(v2) // oops
  }

的所有实现TypeClasses包含其底层的隐式范围TypeClass，其中，T1是最简单和具体的定义ForH，不幸的是它不起作用。 @Dan Simon 提出了一项改进（在T2），它使用类型参数来让spark编译器发现ForH <:< Base.Aux[HNil]

现在想象一下，我想扩展@Dan Simon 的解决方案，以便类型类适用于所有类，例如ForH对于不同类型的 HList（HNil 的超级特征）。 2 个自然扩展位于T3 & T4分别。

不幸的是，它们都不起作用。这T4可以用以下事实来解释ForH <:< Aux[HList]是无效的，但是T3不能用这个借口。另外，也没有办法改进它才能编译成功。

为什么类型类召唤算法在这种情况下失败了？应该怎样做才能使类型类模式真正起作用？

Again, T1.summon(v)无法编译，因为T1.t1不是候选者，手动解决T1.summon(v)(T1.t1)不编译。

For T3 and T4 T3.t1[HNil, Base.ForH], T4.t1[HNil, Base.ForH]将成为候选人

T3.summon(v)(T3.t1[HNil, Base.ForH]) // compiles
T4.summon(v)(T4.t1[HNil, Base.ForH]) // compiles

但问题是H首先被推断并且被推断为Nothing but t1[Nothing, Base.ForH]不满足类型限制。

所以问题不在于隐式解析算法，没关系，问题在于类型推断（我们都知道它在 Scala 中相当弱）。

你可以预防H推断得太快Nothing如果你修改T3.t1, T4.t1

object T3 extends TypeClasses {    
  implicit def t1[
    H <: HList,
    T <: Base/*.Lt[H]*/
  ](implicit ev: T <:< Base.Lt[H]): TypeClass[T] = new TypeClass[T] {
    type HH = H
  }
}

object T4 extends TypeClasses { 
  implicit def t1[
    H <: HList,
    T <: Base/*.Aux[H]*/
  ](implicit ev: T <:< Base.Aux[H]): TypeClass[T] = new TypeClass[T] {
    type HH = H
  }
}

T3.summon(v) // compiles
T4.summon(v) // compiles