Question

据我了解，依赖类型使您可以保留未指定的输出类型：

例如，如果您有类型类：

trait Last[In] {
  type Out
}

然后您可以召唤一个实例，而未指定输出类型：

implicitly(Last[String :: Int :: HNil]) // output type calculated as Int

通过Aux模式，您可以再次指定输出类型：

implicitly(Last.Aux[String :: Int :: HNil, Int])

您需要在隐式参数列表中使用它来对输出类型（to work around a Scala limitation on dependent types）进行一些有用的操作。

但是，如果您始终需要指定输出类型（或为输出类型分配类型参数），为什么首先要使用依赖类型（然后使用Aux）呢？

我尝试从Shapeless的src复制Last类型类，用特征中的附加类型param替换type Out并删除Aux。仍然有效。

我实际需要它们时会怎样？

Answer 1

我发现Sum[A, B]与Sum[A, B] { type Out = C }不同，或者 Sum.Aux[A, B, C]。我在问为什么我根本需要键入Out而不是只是Sum[A, B, C]。

区别在于部分应用。对于trait MyTrait { type A; type B; type C }，您可以指定一些类型，而不能指定其他类型（希望编译器会推断出它们）。但是对于trait MyTrait[A, B, C]，您只能指定所有一个，也不能指定任何一个。对于Sum[A, B] { type Out }，您宁愿指定A，B，而不要指定Out（因为编译器会根据作用域中存在的隐式推断其值）。同样，对于trait Last[In] { type Out }，您宁愿指定In而不指定Out（因为编译器会推断出其值）。因此，类型参数更像输入，而类型成员更像输出。

https://www.youtube.com/watch?v=R8GksuRw3VI

Abstract types versus type parameters和链接的问题

但是确切地说，我愿意指定In而不指定Out吗？

让我们考虑以下示例。这是用于添加自然数的类型类：

sealed trait Nat
case object Zero extends Nat
type Zero = Zero.type
case class Succ[N <: Nat](n: N) extends Nat

type One = Succ[Zero]
type Two = Succ[One]
type Three = Succ[Two]
type Four = Succ[Three]
type Five = Succ[Four]

val one: One = Succ(Zero)
val two: Two = Succ(one)
val three: Three = Succ(two)
val four: Four = Succ(three)
val five: Five = Succ(four)

trait Add[N <: Nat, M <: Nat] {
  type Out <: Nat
  def apply(n: N, m: M): Out
}

object Add {
  type Aux[N <: Nat, M <: Nat, Out0 <: Nat] = Add[N, M] { type Out = Out0 }
  def instance[N <: Nat, M <: Nat, Out0 <: Nat](f: (N, M) => Out0): Aux[N, M, Out0] = new Add[N, M] {
    override type Out = Out0
    override def apply(n: N, m: M): Out = f(n, m)
  }

  implicit def zeroAdd[M <: Nat]: Aux[Zero, M, M] = instance((_, m) => m)
  implicit def succAdd[N <: Nat, M <: Nat, N_addM <: Nat](implicit add: Aux[N, M, N_addM]): Aux[Succ[N], M, Succ[N_addM]] =
    instance((succN, m) => Succ(add(succN.n, m)))
}

这种类型的类都可以在类型级别上使用

implicitly[Add.Aux[Two, Three, Five]]

和价值水平

println(implicitly[Add[Two, Three]].apply(two, three))//Succ(Succ(Succ(Succ(Succ(Zero)))))
assert(implicitly[Add[Two, Three]].apply(two, three) == five)//ok

现在让我们用type参数而不是type member重写它：

trait Add[N <: Nat, M <: Nat, Out <: Nat] {
  def apply(n: N, m: M): Out
}

object Add {
  implicit def zeroAdd[M <: Nat]: Add[Zero, M, M] = (_, m) => m
  implicit def succAdd[N <: Nat, M <: Nat, N_addM <: Nat](implicit add: Add[N, M, N_addM]): Add[Succ[N], M, Succ[N_addM]] =
    (succN, m) => Succ(add(succN.n, m))
}

在类型级别上，它的工作原理类似

implicitly[Add[Two, Three, Five]]

但是在值级别上，您现在必须指定类型Five，而在前一种情况下，类型是由编译器推断的。

println(implicitly[Add[Two, Three, Five]].apply(two, three))//Succ(Succ(Succ(Succ(Succ(Zero)))))
assert(implicitly[Add[Two, Three, Five]].apply(two, three) == five)//ok

所以区别在于部分应用。

但是，如果您像往常一样添加+语法糖，实用的（无形的也适用于所有事物），依赖类型似乎无关紧要

语法并非总是有用。例如，让我们考虑一个接受一个类型（但不包含该类型的值）并产生该类型和该类型的值的类型类：

trait MyTrait {
  type T
}

object Object1 extends MyTrait
object Object2 extends MyTrait

trait TypeClass[In] {
  type Out
  def apply(): Out
}

object TypeClass {
  type Aux[In, Out0] = TypeClass[In] { type Out = Out0 }
  def instance[In, Out0](x: Out0): Aux[In, Out0] = new TypeClass[In] {
    override type Out = Out0
    override def apply(): Out = x
  }

  def apply[In](implicit tc: TypeClass[In]): Aux[In, tc.Out] = tc

  implicit val makeInstance1: Aux[Object1.T, Int] = instance(1)
  implicit val makeInstance2: Aux[Object2.T, String] = instance("a")
}

println(TypeClass[Object1.T].apply())//1
println(TypeClass[Object2.T].apply())//a

但是如果我们将Out设置为类型参数，则在调用时必须指定Out，并且无法定义扩展方法并从元素类型推断类型参数In，因为没有Object1.T，Object2.T类型的元素。

Shapeless何时需要依赖类型？

1 个答案: