那么，让我们将它加载到 type_operators 的一个调用中，看看它的样子。它与表格非常相似，但有一些添加（我现在省略了 Undefined，因为它还不相关）

type_operators! {
    [A, B, C, D, E]

    concrete Nat => usize {
        P => 0,
        I(N: Nat = P) => 1 + 2 * N,
        O(N: Nat = P) => 2 * N,
    }

    (Sum) Adding(Nat, Nat): Nat {
        [P, P] => P
        forall (N: Nat) {
            [(O N), P] => (O N)
            [(I N), P] => (I N)
            [P, (O N)] => (O N)
            [P, (I N)] => (I N)
        }
        forall (N: Nat, M: Nat) {
            [(O M), (O N)] => (O (# M N))
            [(I M), (O N)] => (I (# M N))
            [(O M), (I N)] => (I (# M N))
            [(I M), (I N)] => (O (# (# M N) I))
        }
    }
}

有几个需要注意的地方。首先，定义 (Sum) Adding(Nat, Nat): Nat。这意味着，“这个类型运算符接受两个 Nat 作为输入，并输出一个 Nat。”由于加法是在底层实现为一个递归特质，这意味着我们得到一个形如的特质定义

pub trait Adding<A: Nat>: Nat {
    type Output: Nat;
}

(Sum) 部分为我们声明了一个方便的别名，所以我们可以不用输入 <X as Adding<Y>>::Output 来获取两个数的和，而是输入 Sum<X, Y>。更简洁。

首先，“量词”部分（包含forall的部分）可以避免Rust在类型变量未声明时发出警告。在任何特定的泛型impl中，我们必须考虑在该impl中可以使用的类型变量/泛型类型参数。forall部分修改了impl的序言。例如，forall (N: Nat)使得其内部的所有impl都被声明为impl<N: Nat> ...，而不是impl...，这样我们就可以在那些表达式中使用N作为变量。

这就是我们简短介绍的结束。最后，这里是一些我们这个小LISP方言特有的符号，它们只能在DSL规则右侧使用。

• (@TypeOperator ...)调用另一个类型操作符（可以是原始调用者！）并生成适当的特性界限。
• (% ...)类似于(# ...)，但不会生成任何特性界限。
• (& <type> where (<where_clause>) (<where_clause>) ...)允许为特定的impl定义自定义的where子句。它可以在DSL规则右侧的任何位置出现，但通常应该始终在顶层编写，以确保一致性。

此外，还可以在data和concrete定义以及它们内部的各个元素上使用属性，如#[derive(...)]或#[cfg(...)]。此外，还可以为规则的impl添加属性。例如

type_operators! {
    [A, B, C, D, E]

    data Nat: Default + Debug where #[derive(Default, Debug)] {
        P,
        I(Nat = P),
        O(Nat = P),
        #[cfg(features = "specialization")]
        Error,
        #[cfg(features = "specialization")]
        DEFAULT,
    }

    (Sum) Adding(Nat, Nat): Nat {
        [P, P] => P
        forall (N: Nat) {
            [(O N), P] => (O N)
            [(I N), P] => (I N)
            [P, (O N)] => (O N)
            [P, (I N)] => (I N)
        }
        forall (N: Nat, M: Nat) {
            [(O M), (O N)] => (O (# M N))
            [(I M), (O N)] => (I (# M N))
            [(O M), (I N)] => (I (# M N))
            [(I M), (I N)] => (O (# (# M N) I))

            #[cfg(features = "specialization")] {
                {M, N} => Error
            }
        }
    }
}