一、源码

这个模块实现了类型级别的二进制数标准化处理，确保二进制数在组合时保持最简形式。

//! 二进制数字标准化模块
//!
//! 提供二进制数字(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; //该规则仅用于小数部分

二、模块基础结构

类型定义

模块使用了以下基础类型（来自crate::number）：

Null - 表示空位/终止位
O - 表示二进制0
I - 表示二进制1
B<H, L> - 二进制数构造器，H是高位，L是最低位
Bit - trait，被O和I实现

核心Trait


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

这是一个泛型trait，用于定义标准化行为：

L - 输入的最低位类型
Output - 标准化后的输出类型
normalize - 执行标准化的方法

三、标准化规则实现

基础情况 - 处理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()是构造新二进制数的函数

规则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）

规则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）

通用情况 - 处理嵌套结构


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"）

纯小数规则
简化情况：


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>>
用于处理更复杂的小数部分结构

类型别名


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;