一、源码

代码实现了类型系统中的"加一"操作（Add1 trait），用于在编译期进行数字的增量计算。

//! 加一操作特质实现 / Increment operation trait implementation
//!
//! 说明：
//!     1. Z0、P1,、N1 + 1，常规计算
//!     2. B0<H> + 1，该位B1，无进位，原高位是N1时要规范格式，即H=N1时要特化，此时源码为B0<N1>
//!     3. B1<H> + 1，该位B0，有进位，当H+1 = Z0时要规范格式,即H=N1时要特化，此时源码为B1<N1>，不是简化格式

use super::basic::{B0, B1, Z0, P1, N1, NonZero, NonNegOne};

/// 加一特质 / Increment trait
/// 
/// 为类型系统提供加一操作的计算能力
/// Provides increment operation capability for type system
pub trait Add1 {
    /// 加一后的输出类型 / Output type after increment
    type Output;
}

// ========== 基础类型实现 / Basic Type Implementations ==========

/// Z0 (0) 加一实现 / Increment for Z0 (0)
/// 
/// 0 + 1 = 1 (B1<Z0>)
impl Add1 for Z0 {
    type Output = P1;  //P1替换B1<Z0>
}

/// P1 (1) 加一实现 / Increment for P1 (+1)
/// 
/// 1 + 1 = 2 (B0<P1>)
impl Add1 for P1 {
    type Output = B0<P1>;
}

/// N1 (-1) 加一实现 / Increment for N1 (-1)
/// 
/// -1 + 1 = 0 (Z0)
impl Add1 for N1 {
    type Output = Z0; 
}



// ========== 递归类型实现 / Recursive Type Implementations ==========

/// B0<H> 加一实现 / Increment for B0<H>
/// 
/// 直接加一无需进位 / Direct increment without carry
/// ...0 + 1 = ...1 / ...0 + 1 = ...1
impl<H:NonZero + NonNegOne> Add1 for B0<H>{//P1替代B1<Z0>后，H不可能为Z0
    type Output = B1<H>;
}

/// B1<H> 加一实现 / Increment for B1<H>
/// 
/// 处理进位情况 / Handles carry case
/// 0...1 + 1 = 0...(高位进位) / ...1 + 1 = ...0(with carry)
impl<H:NonZero + NonNegOne + Add1> Add1 for B1<H>{//P1替代B1<Z0>后，H不可能为Z0
    type Output = B0<H::Output>;
}

// ========== 特化实现 ==========
/// B0<N1> (-2) 加一特化实现 / Specialized increment for B0<N1> (-2)
impl Add1 for B0<N1> {
    type Output = N1;
}

// B1<N1> (-1) 加一特化实现，本身不允许B1<N1>出现,其结果也是不规范的格式，目前取消
/* impl Add1 for B1<N1> {
    type Output = Z0;
} */

二、核心设计

1. Add1 trait：定义了一个关联类型 Output 表示加一后的结果类型

2. 分层实现：

• 基础类型实现（Z0, P1, N1）

• 递归类型实现（B0, B1）

• 特化实现（处理边界情况）

三、基础类型实现

1. Z0 (零) 加一

impl Add1 for Z0 {
    type Output = P1;  // 0 + 1 = 1
}

原先可能返回 B1，现在简化为直接返回 P1

2. P1 (正一) 加一

impl Add1 for P1 {
    type Output = B0<P1>;  // 1 + 1 = 2 (二进制表示为 10)
}

使用二进制表示法，B0 表示 “10”（高位1，低位0）

3. N1 (负一) 加一

impl Add1 for N1 {
    type Output = Z0;  // -1 + 1 = 0
}

四、递归类型实现

1. B0 加一（无进位）

impl<H: NonZero + NonNegOne> Add1 for B0<H> {
    type Output = B1<H>;  // ...0 + 1 = ...1
}

• 将最低位从0变为1，不需要进位

• 约束 H 必须是非零且非负一（因为 P1 替代了 B1，所以 H 不可能是 Z0）

2. B1 加一（有进位）

impl<H: NonZero + NonNegOne + Add1> Add1 for B1<H> {
    type Output = B0<H::Output>;  // ...1 + 1 = ...0 (带进位)
}

• 将最低位从1变为0，并对高位 H 进行进位操作

• 要求 H 也必须实现 Add1 trait

五、特化实现

B0 (-2) 加一

impl Add1 for B0<N1> {
    type Output = N1;  // -2 + 1 = -1
}

• 这是一个特殊情况处理，直接返回 N1 而不是 B1（为了保持规范格式）

注释掉的 B1 实现

/* impl Add1 for B1<N1> {
    type Output = Z0;
} */

• 原本处理 -1 + 1 = 0 的情况

• 但 B1 被视为不规范格式，所以注释掉了

六、关键点说明

1. 二进制表示：

• B0 表示在二进制表示中添加一个0

• B1 表示添加一个1

• 例如 B0 表示二进制 10（即十进制2）

2. 规范化处理：

• 避免出现 B1 这样的不规范表示

• 用P1 替代了原先的 B1 。

3. 类型约束：

• NonZero 确保不会对零进行递归操作（因为 P1 已经替代了 B1）

• NonNegOne 确保不会对负一进行递归操作，后面有对负一的特化处理

这种设计使得类型系统可以在编译期完成数字计算，常用于需要类型安全数学运算的场景，如静态数组大小计算、物理单位系统等。