Scala 超过2种类型的无形状类型析取

如何为shapeless中的3个或更多类型提供类型析取？例如：

import shapeless._

object Tst extends App {

  sealed trait Base

  final case class A() extends Base
  final case class B() extends Base
  final case class C() extends Base
  final case class D() extends Base

  def AorB[T: (A |∨| B)#λ](t: T): Unit =
    t match {
      case _: A => println("A")
      case _: B => println("B")
    }
  AorB(A()) //Ok
  AorB(B()) //Ok

  def AorBorC[T: (A |∨| B |∨| C)#λ](t: T): Unit =
    t match {
      case _: A => println("A")
      case _: B => println("B")
      case _: C => println("C")
    }
  AorBorC(A()) //compile-error
  AorBorC(B()) //compile-error
  AorBorC(C()) //Ok
}

从两种类型的析取可以看出，它工作得非常好。但对于3种类型的析取，它并不像预期的那样工作

编译错误包括：

Error:(28, 10) Cannot prove that (Tst.A => Nothing) => Nothing <:< Object{type λ[X] = (X => Nothing) => Nothing <:< Tst.A => Nothing with Tst.B => Nothing => Nothing} => Nothing with Tst.C => Nothing => Nothing.
  AorBorC(A())

Error:（28,10）无法证明（Tst.A=>Nothing=>Nothing=>Nothing=>Tst.B=>Nothing=>Nothing}=>Nothing=>Tst.C=>Nothing=>Nothing。
AorBorC（A（））

及

Error:（29,10）无法证明（Tst.B=>Nothing=>Nothing）=>Nothing-Nothing-with-Tst.B=>Nothing=>Nothing}=>Nothing-with-Tst.C=>Nothing=>Nothing。
AorBorC（B（））

不成形|∨|不适用于超过2种类型


对于2种以上的类型，编码变得更加复杂

一种编码是2，4，8。。。类型

type ¬¬¬¬[T] = ¬¬[¬¬[T]]
type |∨∨|[T, U] = {
  type λ[X] = ¬¬¬¬[X] <:< (T ∨ U)
}

def AorBorC[T: ((A ∨ B) |∨∨| (C ∨ C))#λ](t: T): Unit =
  t match {
    case _: A => println("A")
    case _: B => println("B")
    case _: C => println("C")
  }

AorBorC(A()) //Ok
AorBorC(B()) //Ok
AorBorC(C()) //Ok

类型[T]=[T]]
类型|∨∨|[T，U]={
类型λ[X]=，，，，，[X]println（“A”）
案例：B=>println（“B”）
案例：C=>println（“C”）
}
AorBorC（A（））//好的
AorBorC（B（））//好的
AorBorC（C（））//好的

另一种是针对任意数量的类型

trait Disj[T] {
  type or[S] = Disj[T with ¬[S]]
  type apply = ¬[T]
}

type ∨∨∨[T1, T2, T3] = Disj[¬[T1]]#or[T2]#or[T3]#apply

type |∨∨∨|[T1, T2, T3] = {
  type λ[X] = ¬¬[X] <:< ∨∨∨[T1, T2, T3]
}

def AorBorC[T: |∨∨∨|[A, B, C]#λ](t: T): Unit =
  t match {
    case _: A => println("A")
    case _: B => println("B")
    case _: C => println("C")
  }

AorBorC(A()) //Ok
AorBorC(B()) //Ok
AorBorC(C()) //Ok

trait Disj[T]{
类型或[S]=Disj[T，带[S]]
类型apply=，[T]
}
类型∨∨∨[T1，T2，T3]=Disj[，[T1]#或[T2]#或[T3]#适用
类型|∨∨∨|[T1、T2、T3]={
类型λ[X]=，，，[X]println（“A”）
案例：B=>println（“B”）
案例：C=>println（“C”）
}
AorBorC（A（））//好的
AorBorC（B（））//好的
AorBorC（C（））//好的


trait Disj[T] {
  type or[S] = Disj[T with ¬[S]]
  type apply = ¬[T]
}

type ∨∨∨[T1, T2, T3] = Disj[¬[T1]]#or[T2]#or[T3]#apply

type |∨∨∨|[T1, T2, T3] = {
  type λ[X] = ¬¬[X] <:< ∨∨∨[T1, T2, T3]
}

def AorBorC[T: |∨∨∨|[A, B, C]#λ](t: T): Unit =
  t match {
    case _: A => println("A")
    case _: B => println("B")
    case _: C => println("C")
  }

AorBorC(A()) //Ok
AorBorC(B()) //Ok
AorBorC(C()) //Ok