【unitrix】 5.2 第二套类型级二进制数规范化代码(normalize2.rs)

一、源码

这段代码实现了一个二进制数字标准化模块，目的是确保二进制数在组合时保持最简洁的形式，避免同一个数值有不同的表示方式（比如 B<B<Null, O>, O> 和 B<Null, O> 实际上都表示 0，但前者是冗余的）。

//! 二进制数字标准化模块
//! 
//! 提供将二进制数字(B<H, L>)在组合成B结构体前判断和标准化为最简洁的形式，避免同一个数有不同表示形式
//! 
//! 例如 H为B<Null,O>,L为O时 => B<Null,O>, H为B<Null,I,L为I时 => B<Null,I>

use crate::number::{O, I, B, Null, Bit};

pub trait NormalizeIf<X: Bit> {
    type Output;
    fn normalize(self, bit: X) -> Self::Output;
}

// /* 处理高位为Null情况 */
impl NormalizeIf<X: Bit> for Null {
    type Output = B<Null, O>;
    fn normalize(self, bit: X) -> Self::Output {
        B(Null, bit)
    }
}

// /* 处理高位的高位为Null的情况 */
// 实现规则1: L=O 且 H=B<Null, O> => 简化为 B<Null, O>
impl NormalizeIf<O> for B<Null, O> {
    type Output = Self;
    fn normalize(self, _bit: O) -> Self::Output {
        self
    }
}

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

// 实现规则2: L=I 且 H=B<Null, I> => 简化为 B<Null, I>
impl NormalizeIf<I> for B<Null, I> {
    type Output = Self;
    fn normalize(self, _bit: I) -> Self::Output {
        self
    }
}

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

// /* 处理高位为嵌套的B<B<H,L1>,L2>情况 */
// 默认情况: 更高位认为是简化过的，或手动调用该特质触发简化代码
impl<H, L: Bit, L1: Bit, L2: Bit> NormalizeIf<L> for B<B<H, L1>, L2> {
    type Output = B<Self, L>;
    fn normalize(self, bit: L) -> Self::Output {
        B(self, bit)
    }
}

二、代码结构解析

1. 导入依赖

use crate::number::{O, I, B, Null, Bit};

• O (0), I (1): 表示二进制位 0 和 1。

• B<H, L>: 表示一个二进制数，其中 H 是高位部分，L 是最低位。

• Null: 表示二进制数的终止（类似于 None 或空位）。

• Bit: 是一个 trait，表示 O 和 I 都实现了它。

2. NormalizeIf Trait

pub trait NormalizeIf<X: Bit> {
    type Output;
    fn normalize(self, bit: X) -> Self::Output;
}

• 作用：定义一个标准化方法，用于优化 B<H, L> 结构。

• 泛型参数：

  • X: 表示最低位 L（只能是 O 或 I）。

• 关联类型：

  • Output: 标准化后的返回类型。

• 方法：

  • normalize(self, bit: X): 接收 self（高位部分 H）和 bit（最低位 L），返回优化后的结构。

3. 标准化规则实现
   (1) Null 的情况（空位）

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

• 作用：如果 H 是 Null（即当前二进制数没有更高位），则直接构造 B<Null, L>。

• 示例：

  • Null.normalize(O) → B<Null, O>（即 0）。

• Null.normalize(I) → B<Null, I>（即 1）。

(2) H = B<Null, O> 的情况（高位是 0）

// 规则1: L=O 且 H=B<Null, O> => 简化为 B<Null, O>
impl NormalizeIf<O> for B<Null, O> {
    type Output = Self;
    fn normalize(self, _bit: O) -> Self::Output {
        self
    }
}

// 如果 L=O 但 H=B<Null, I> => 不简化，直接构造 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(self, O)
    }
}

// 如果 L=I 但 H=B<Null, O> => 不简化，直接构造 B<B<Null, O>, I>
impl NormalizeIf<I> for B<Null, O> {
    type Output = B<Self, I>;
    fn normalize(self, bit: I) -> Self::Output {
        B(self, bit)
    }
}

• 规则1：

  • 如果 H = B<Null, O>（即 0），且 L = O（0），则直接返回 B<Null, O>（即 0），避免 B<B<Null, O>, O> 这样的冗余结构。

• 其他情况：

  • H = B<Null, I> + L = O → B<B<Null, I>, O>（即 10）。

  • H = B<Null, O> + L = I → B<B<Null, O>, I>（即 01）。

(3) H = B<Null, I> 的情况（高位是 1）

// 规则2: L=I 且 H=B<Null, I> => 简化为 B<Null, I>
impl NormalizeIf<I> for B<Null, I> {
    type Output = Self;
    fn normalize(self, _bit: I) -> Self::Output {
        self
    }
}

• 规则2：

  • 如果 H = B<Null, I>（即 1），且 L = I（1），则直接返回 B<Null, I>（即 1），避免 B<B<Null, I>, I> 这样的冗余结构。

(4) 默认情况（嵌套 B<B<H, L1>, L2>）

impl<H, L: Bit, L1: Bit, L2: Bit> NormalizeIf<L> for B<B<H, L1>, L2> {
    type Output = B<Self, L>;
    fn normalize(self, bit: L) -> Self::Output {
        B(self, bit)
    }
}

• 作用：

  • 如果 H 本身已经是 B<B<H, L1>, L2>（即更复杂的嵌套结构），则默认不优化，直接构造 B<B<B<H, L1>, L2>, L>。

  • 例如：

    • B<B<Null, O>, I> + O → B<B<B<Null, O>, I>, O>（即 010）。

    • B<B<Null, I>, O> + I → B<B<B<Null, I>, O>, I>（即 101）。

三、标准化示例

四、总结

• 目标：确保二进制数没有冗余的 0 前缀（类似 001 → 1）。

• 主要优化：

  • B<Null, O> + O → B<Null, O>（00 → 0）。
  • B<Null, I> + I → B<Null, I>（11 → 1）。

• 其他情况：

  • 如果 H 已经是 B<…>，则默认不优化，直接构造更深的嵌套结构。

这个模块适用于类型级别的二进制数运算（如类型安全的二进制计算），确保数值的唯一表示形式。