一、源碼

這個模塊實現了類型級別的二進制數標準化處理，確保二進制數在組合時保持最簡形式。

//! 二進制數字標準化模塊
//!
//! 提供二進制數字(B<H, L>)的組合前標準化功能，確保數字以最簡形式表示，
//! 避免同一數值有不同表示形式。
//!
//! 示例：
//! - 當 H = B<Null, O> 且 L = O 時 => 標準化為 B<Null, O>
//! - 當 H = B<Null, I> 且 L = I 時 => 標準化為 B<Null, I>
//! - 當 H = O 且 L = Null 時 => 標準化為 Null
//! 
use crate::number::{Null, O, I, B, Bit};/// 標準化條件判斷 trait
/// 根據給定的最低位(L)對數字進行標準化處理
pub trait NormalizeIf<L> {type Output;fn normalize(self, l:L) -> Self::Output;
}// 基礎情況：當高位為 Null 時，直接構造 B<Null, X>
impl<X: Bit> NormalizeIf<X> for Null {type Output = B<Null, X>;fn normalize(self, _: X) -> Self::Output {B::new()}
}// 規則1: 當 H = B<Null, O> 且 L = O 時，簡化成高位
impl NormalizeIf<O> for B<Null, O> {type Output = Self;fn normalize(self, _: O) -> Self::Output {self}
}// 規則1補充: 當 H = B<Null, I> 且 L = O 時，構造 B<B<Null, I>, O>
impl NormalizeIf<O> for B<Null, I> {type Output = B<Self, O>;fn normalize(self, _bit: O) -> Self::Output {B::new()}
}// 規則2: 當 H = B<Null, I> 且 L = I 時，簡化成高位
impl NormalizeIf<I> for B<Null, I> {type Output = Self;fn normalize(self, _: I) -> Self::Output {self}
}// 規則2補充: 當 H = B<Null, O> 且 L = I 時，構造 B<B<Null, O>, I>
impl NormalizeIf<I> for B<Null, O> {type Output = B<Self, I>;fn normalize(self, _: I) -> Self::Output {B::new()}
}// 通用情況: 對于更復雜的嵌套結構(B<B<B<HH, HL>, L>, LL>)，保持原結構
// 假設更高位已經是簡化過的，或者需要手動調用該 trait 進行簡化
impl<HH, HL: Bit, L: Bit, LL: Bit> NormalizeIf<LL> for B<B<HH, HL>, L> {type Output = B<Self, LL>;fn normalize(self, bit: LL) -> Self::Output {B::new()}
}// 純小數規則: 當 L = Null 且 H = O 時，簡化成低位
impl NormalizeIf<Null> for O {type Output = Self;fn normalize(self, bit: Null) -> Self::Output {bit}
}// 純小數規則補充1: 當 L = Null 且 H = I 時，構造 B<I, Null>
impl NormalizeIf<Null> for I {type Output = B<I, Null>;fn normalize(self, _bit: Null) -> Self::Output {B::new()}
}// 純小數規則補充2: 當 L = B結構體B<LH， LL> 且 H 為Bit 時，構造 B<H, B<LH, LL>>
// 假設更低位已經是簡化過的，或者需要手動調用該 trait 進行簡化
impl<H: Bit, LH: Bit, LL> NormalizeIf<B<LH, LL>> for H {type Output = B<H, B<LH, LL>>;fn normalize(self, _bit: B<LH, LL>) -> Self::Output {B::new()}
}pub type IfB0<H> = <H as NormalizeIf<O>>::Output;
pub type IfB1<H> = <H as NormalizeIf<I>>::Output;
pub type IfNull<H> = <H as NormalizeIf<Null>>::Output; //該規則僅用于小數部分

二、模塊基礎結構

1. 類型定義

模塊使用了以下基礎類型（來自crate::number）：

• Null - 表示空位/終止位

• O - 表示二進制0

• I - 表示二進制1

• B<H, L> - 二進制數構造器，H是高位，L是最低位

• Bit - trait，被O和I實現

2. 核心Trait

pub trait NormalizeIf<L> {type Output;fn normalize(self, l: L) -> Self::Output;
}

這是一個泛型trait，用于定義標準化行為：

• L - 輸入的最低位類型

• Output - 標準化后的輸出類型

• normalize - 執行標準化的方法

三、標準化規則實現

1. 基礎情況 - 處理Null高位

impl<X: Bit> NormalizeIf<X> for Null {type Output = B<Null, X>;fn normalize(self, _: X) -> Self::Output {B::new()}
}

• 當高位是Null時，直接構造B<Null, X>

• 例如：Null + O → B<Null, O> (表示0)

• B::new()是構造新二進制數的函數

2. 規則1 - 處理O(0)結尾的情況
   簡化情況：

impl NormalizeIf<O> for B<Null, O> {type Output = Self;fn normalize(self, _: O) -> Self::Output {self}
}

• 當H = B<Null, O>且L = O時，保持原樣

• 避免B<B<Null,O>,O>這樣的冗余結構，直接返回B<Null,O>

非簡化情況：

impl NormalizeIf<O> for B<Null, I> {type Output = B<Self, O>;fn normalize(self, _bit: O) -> Self::Output {B::new()}
}

• 當H = B<Null, I>且L = O時，構造B<B<Null,I>,O>

• 表示二進制"10"（十進制2）

3. 規則2 - 處理I(1)結尾的情況
   簡化情況：

impl NormalizeIf<I> for B<Null, I> {type Output = Self;fn normalize(self, _: I) -> Self::Output {self}
}

• 當H = B<Null, I>且L = I時，保持原樣

• 避免B<B<Null,I>,I>這樣的冗余結構，直接返回B<Null,I>

非簡化情況：

impl NormalizeIf<I> for B<Null, O> {type Output = B<Self, I>;fn normalize(self, _: I) -> Self::Output {B::new()}
}

• 當H = B<Null, O>且L = I時，構造B<B<Null,O>,I>

• 表示二進制"01"（十進制1）

4. 通用情況 - 處理嵌套結構

impl<HH, HL: Bit, L: Bit, LL: Bit> NormalizeIf<LL> for B<B<HH, HL>, L> {type Output = B<Self, LL>;fn normalize(self, bit: LL) -> Self::Output {B::new()}
}

• 對于更復雜的嵌套結構（如B<B<B<H,L1>,L2>），保持原結構

• 假設更高位已經是簡化過的，或者需要手動調用該trait進行簡化

• 例如：B<B<Null,O>,I> + O → B<B<B<Null,O>,I>,O>（表示"010"）

5. 純小數規則
   簡化情況：

impl NormalizeIf<Null> for O {type Output = Self;fn normalize(self, bit: Null) -> Self::Output {bit}
}

• 處理小數部分，當H = O且L = Null時，返回Null

• 用于表示純小數如"0.xxx"

非簡化情況：

impl NormalizeIf<Null> for I {type Output = B<I, Null>;fn normalize(self, _bit: Null) -> Self::Output {B::new()}
}

• 當H = I且L = Null時，構造B<I, Null>

• 用于表示純小數如"1.xxx"

impl<H: Bit, LH: Bit, LL> NormalizeIf<B<LH, LL>> for H {type Output = B<H, B<LH, LL>>;fn normalize(self, _bit: B<LH, LL>) -> Self::Output {B::new()}
}

• 當L是B結構體且H為Bit時，構造B<H, B<LH, LL>>

• 用于處理更復雜的小數部分結構

3. 類型別名

pub type IfB0<H> = <H as NormalizeIf<O>>::Output;
pub type IfB1<H> = <H as NormalizeIf<I>>::Output;
pub type IfNull<H> = <H as NormalizeIf<Null>>::Output;

這些類型別名提供了：

• IfB0 - 當最低位是O時的標準化結果

• IfB1 - 當最低位是I時的標準化結果

• IfNull - 專門用于小數部分的標準化

五、設計模式分析

這個模塊體現了多種設計模式：

• 策略模式：通過不同的trait實現提供不同的標準化策略

• 遞歸結構：使用泛型和關聯類型處理嵌套的二進制結構

• 類型級編程：在編譯期完成所有標準化操作

• 零成本抽象：運行時沒有任何額外開銷

六、使用示例

有以下二進制數：

• B<Null, O> → 0

• B<Null, I> → 1

• B<B<Null, O>, I> → 01 (1)

• B<B<Null, I>, O> → 10 (2)

標準化過程會確保：

1. B<Null, O> + O → B<Null, O> (而不是B<B<Null,O>,O>)

2. B<Null, I> + I → B<Null, I> (而不是B<B<Null,I>,I>)

3. 更復雜的結構保持原樣，除非有明確的簡化規則

七、總結

這個二進制標準化模塊：

1. 通過類型系統保證二進制數的規范表示

2. 消除冗余的前導零和重復結構

3. 支持整數和小數部分的標準化

4. 在編譯期完成所有處理，運行時無開銷

5. 為類型安全的二進制運算提供基礎

這種設計在需要精確控制二進制表示的場合（如物理單位、協議實現等）特別有用，可以避免許多潛在的邊界情況錯誤。