Когда нужны зависимые типы в Shapeless? - PullRequest
Новая
       20

Когда нужны зависимые типы в Shapeless?

0 голосов
/ 02 июля 2018

Как я понимаю, зависимые типы позволяют вам оставлять типы вывода неуказанными:

Например, если у вас есть класс типа: 

trait Last[In] {
  type Out
}

тогда вы могли бы вызвать экземпляр, не указав тип вывода: 

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

И шаблон Aux позволяет вам снова указать тип вывода: 

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

, который вам нужен в неявном списке параметров, чтобы сделать что-то полезное с типом вывода (, чтобы обойти ограничение Scala для зависимых типов ).

Но если вам всегда нужно указывать (или присваивать параметру типа) тип вывода, зачем вообще использовать зависимые типы (а затем и Aux)?

Я попытался скопировать класс типа Last из src Shapeless, заменив type Out дополнительным параметром типа в признаке и удалив Aux. Это все еще работает.

Какова ситуация, когда они мне действительно нужны?

1 Ответ

0 голосов
/ 03 июля 2018

Я понял, что 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

Абстрактные типы и параметры типа и связанные вопросы

Но когда именно, я бы предпочел указать 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

Теперь давайте перепишем его с параметром типа вместо члена типа: 

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.

...