在 scala 中，如何使 type class 为 Aux 模式工作？

Question

这是一个简单的例子：

  trait Base {

    type Out
    def v: Out
  }

  object Base {

    type Aux[T] = Base { type Out = T }

    class ForH() extends Base {

      type Out = HNil

      override def v: Out = HNil
    }

    object ForH extends ForH
  }

  class TypeClass[B]

  trait TypeClassLevel1 {

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

  object TypeClass extends TypeClassLevel1 {

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

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

  it("No Aux") {

    val v = 2

    TypeClass.summon(v) // works
  }


  it("Aux") {

    val v = new Base.ForH()

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

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

对象Base/ForH显然有一个稳定的路径，这消除了编译器无法解析类型ForH.Out的可能性。

困扰我的不是编译器如何无法弄清楚 ForH <:< Aux[HNil] 的事实，而是修补它是多么容易，只需通过简单的类型向上转换（最后 2 行）。恕我直言，这两个功能（类型 lambda 和类型 classes）都是函数式编程的重要方面，为什么它们不能同时一起工作？

如果您熟悉编译器设计，我会提出一个额外的问题：如何改进类型 class 搜索算法以实现它？非常感谢您的意见。

更新 1：已提出具体修复，但我在尝试概括时遇到另一个问题，请参阅 In scala, how to make type class working for Aux pattern? - Part 2 了解详细信息

Answer 1

所以编译器能够推断出 ForH <:< Aux[HNil]，但是（说实话我不知道为什么）当 return 类型使用类型 lambda 解析隐式时，如果你没有使用类型绑定。

无论如何，这可能不是一个很好的解释，但至少我可以让你的代码编译。只需将 t1 更改为：

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

这对我在使用 Scala 2.13.4 的 scastie 中有效。

Answer 2

What bothers me is not how incapable the compiler is to figure out the fact that ForH <:< Aux[HNil]

编译器肯定能看到 Base.ForH <:< Base.Aux[HNil]。你可以检查

implicitly[Base.ForH <:< Base.Aux[HNil]]

编译。

IMHO both features (type lambda & type classes) are important aspect of functional programming, why they can't work together at the same time?

你为什么要谈论 lambda 类型？我在你的问题中看不到 lambda 类型。

顺便说一句，lambdas 类型不是 Scala 2 的一部分，({ type λ[X] = ...F[X]... })#λ 对于 lambda 类型来说或多或少是一种 hack。实际类型的 lambda 被添加到 Scala 3。

val v = new Base.ForH() 具有类型 Base.ForH（如果没有通过类型归属 val v = new Base.ForH(): Base.Aux[HNil] 或手动类型规范 val v: Base.Aux[HNil] = new Base.ForH() 进行向上转换，则不是 Base.Aux[HNil]）。 TypeClass.summon(v) 不应编译，因为没有隐式 TypeClass[Base.ForH]。作为候选人，您会考虑什么暗示？ TypeClass.t1？但它不是候选，你可以检查明确解决

TypeClass.summon(v)(TypeClass.t1)

无法编译。

what does it take to improve the type class search algorithm to make it happen?

不应该在这个特定的地方改进隐式搜索算法。它按预期正常工作。

您可以使类型 class 逆变

class TypeClass[-B]

然后 TypeClass.t1 将成为 TypeClass[Base.ForH] 的候选者并且 TypeClass.summon(v) 将编译。

In scala 2.13, how to use implicitly[value singleton type]?

在 scala 中，如何使 type class 为 Aux 模式工作？

In scala, how to make type class working for Aux pattern?

scala

abstract-data-type

typeclass

type-alias

scala-2.13