Scala 如何找到正确的隐式编译器？

借助于此，我试图理解Scala中的类型级编程。 让我们考虑提供的代码：

trait Nat
class _0 extends Nat
class Succ[A <: Nat] extends Nat

type _1 = Succ[_0]
type _2 = Succ[_1] // = Succ[Succ[_0]]
type _3 = Succ[_2] // = Succ[Succ[Succ[_0]]]
type _4 = Succ[_3] // ... and so on
type _5 = Succ[_4]

sealed trait <[A <: Nat, B <: Nat]
object < {
    def apply[A <: Nat, B <: Nat](implicit lt: <[A, B]): <[A, B] = lt
    implicit def ltBasic[B <: Nat]: <[_0, Succ[B]] = new <[_0, Succ[B]] {}
    implicit def inductive[A <: Nat, B <: Nat](implicit lt: <[A, B]): <[Succ[A], Succ[B]] = new <[Succ[A], Succ[B]] {}
}

sealed trait <=[A <: Nat, B <: Nat]
object <= {
    def apply[A <: Nat, B <: Nat](implicit lte: <=[A, B]): <=[A, B] = lte
    implicit def lteBasic[B <: Nat]: <=[_0, B] = new <=[_0, B] {}
    implicit def inductive[A <: Nat, B <: Nat](implicit lt: <=[A, B]): <=[Succ[A], Succ[B]] = new <=[Succ[A], Succ[B]] {}
}

trait-Nat
类0扩展了Nat
类Succ[A它不会“减量”任何东西。它只知道
归纳的
可以找到正确的隐式参数，如果它有正确的隐式参数。它不知道它会找到这些参数，但它无论如何都会尝试

给定
的实例，它不会“递减”任何内容。它只知道
归纳的
可以找到正确的隐式参数，如果它有正确的隐式参数。它不知道它会找到这些参数，但它无论如何都会尝试

考虑到
的实例，你可以用一种与编译器相同的非常机械的方法手工解决这个问题。你需要
\u2<\u3
，你有两个选项
\u0
，在这种情况下它不适用，因为
\u2=！=\u0
和
Succ[a]
if
A
so\u2\u1
然后继续向下直到它到达
\u0
所以一切都解决了。你可以手工解决这个问题，用一种与编译器相同的非常机械的方法。你需要
\u2
，你有两个选择
\u0
，在这种情况下它不适用，因为
\u2=！=\u0
和
Succ[A]
如果
A
so{u2`如果
\u1
，它继续向下，直到到达
\u0
，所以一切都解决了。
implicit def inductive[A <: Nat, B <: Nat](implicit lt: <[A, B]): <[Succ[A], Succ[B]]