一、源碼

代碼實現了類型系統中的"加一"操作（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 incrementtype 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不可能為Z0type 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不可能為Z0type 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 確保不會對負一進行遞歸操作，后面有對負一的特化處理

這種設計使得類型系統可以在編譯期完成數字計算，常用于需要類型安全數學運算的場景，如靜態數組大小計算、物理單位系統等。