【unitrix】 5.1 第二套类型级二进制数基本结构体(types2.rs)

一、源码

这段代码定义了一个类型级(type-level)的二进制数表示系统，使用Rust的泛型结构体来实现。

rust 复制代码

//! 类型级二进制数表示方案（第二套方案）
//!
//! 使用嵌套泛型结构体表示二进制数，支持整数和实数表示。
//!
//! # 表示规则
//!
//! - 整数部分使用嵌套的`B`结构体表示，例如：
//!   - `B<Null, O>` 表示 0
//!   - `B<Null, I>` 表示 -1
//!   - `B<B<Null, O>, I>` 表示 1
//!   - `B<B<Null, O>, O>` 表示 0 (高位0可以省略，实际为`B<Null, O>`)
//!
//! - 十进制科学计数法使用`D`结构体表示：
//!   - `D<I, E10>` 表示 I × 10^E10
//!   - 例如 `D<B<Null, I>, B<Null, I>>` 表示 -1 × 10^-1 = -0.1

use crate::sealed::Sealed;

/// 类型级二进制数结构体
///
/// # 泛型参数
/// - `H`: 高位部分
///   - `B<H, L>` 表示嵌套的高位
///   - `Null` 表示无更高位
/// - `L`: 低位部分
///   - `I` 表示1
///   - `O` 表示0
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct B<H, L>(pub H, pub L);

/// 十进制科学计数法表示
///
/// # 泛型参数
/// - `I`: 二进制整数部分
/// - `E10`: 10的幂次（使用二进制表示）
///
/// # 示例
/// ```
/// // -2 × 10^1 = -20.0
/// D<B<I, O>, B<O, I>>;
///
/// // 3 × 10^-2 = 0.03
/// D<B<B<B<Null, O>, I>, I>, B<B<Null, I>, O>>;
/// ```
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct D<I, E10>(pub I, pub E10);

/// 类型级比特位0（逻辑假）
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug, Default)]
pub struct O;

/// 类型级比特位1（逻辑真）
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug, Default)]
pub struct I;

/// 空类型标记，表示无更高位或无小数部分
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug, Default)]
pub struct Null;

// 常用类型别名
pub type Zero = B<Null, O>;
pub type One = B<Null, I>;
pub type NegOne = B<Null, I>;

// 实现Default trait
impl<H: Default, L: Default> Default for B<H, L> {
    fn default() -> Self {
        B(Default::default(), Default::default())
    }
}

impl<I: Default, E10: Default> Default for D<I, E10> {
    fn default() -> Self {
        D(Default::default(), Default::default())
    }
}

// 构造函数实现
impl<H, L> B<H, L> {
    /// 创建新的二进制数实例
    #[inline]
    pub const fn new(h: H, l: L) -> Self {
        B(h, l)
    }
}

impl<I, E10> D<I, E10> {
    /// 创建新的十进制数实例
    #[inline]
    pub const fn new(int: I, exp: E10) -> Self {
        D(int, exp)
    }
}

impl Null {
    /// 创建新的Null实例
    #[inline(always)]
    pub const fn new() -> Self {
        Null
    }
}

impl O {
    /// 创建新的O实例
    #[inline(always)]
    pub const fn new() -> Self {
        O
    }
}

impl I {
    /// 创建新的I实例
    #[inline(always)]
    pub const fn new() -> Self {
        I
    }
}

// 密封标记实现
impl<H, L> Sealed for B<H, L> {}
impl<I, E10> Sealed for D<I, E10> {}
impl Sealed for Null {}
impl Sealed for O {}
impl Sealed for I {}

二、源码分析

核心设计理念

使用嵌套的泛型结构体表示二进制数
支持两种表示形式：
- 纯二进制整数（B结构体）
- 十进制科学计数法（D结构体）

主要结构体

B<H, L> - 二进制数表示

H: 高位部分，可以是另一个B结构体或Null(表示没有更高位)
L: 最低位，可以是O(0)或I(1)
示例：
- B<Null, O>: 0
- B<Null, I>: -1
- B<B<Null, O>, I>: 1 (01，高位0是符号位，不能省略)
- B<B<Null, I>, O>: -2 (10)

D<I, E10> - 十进制科学计数法

I: 整数部分，用B结构体表示
E10: 10的幂次，也用B结构体表示
示例：
- D<B<Null, I>, B<Null, I>>: -1 × 10⁻¹ = -0.1
- D<B<I, O>, B<O, I>>: -2 × 10¹ = -20.0

基本类型

O: 表示二进制位0
I: 表示二进制位1
Null: 表示空/无更高位

类型别名

rust 复制代码

pub type Zero = B<Null, O>;  // 0
pub type One = B<Null, I>;   // -1 (注意这里表示-1)
pub type NegOne = B<Null, I>; // -1

实现细节

派生特质：
- 为所有结构体派生了一系列标准特质(Eq, PartialEq, Clone, Copy, Debug等)
- 实现了Default特质，使得这些类型可以默认构造
构造函数：
- 为每个结构体提供了new方法
- 基本类型(Null, O, I)的构造函数是内联的
密封特质(Sealed)：
- 实现了Sealed特质，这是一种设计模式，用于限制特质只能在当前crate内实现

表示规则特点

使用补码表示法，最高位为1表示负数
高位0可以省略(如B<Null, O>表示0而不是B<B<Null, O>, O>)
高位1可以省略(如B<Null, I>表示-1而不是B<B<Null, I>, I>)
十进制数使用科学计数法表示，便于表示实数

示例解读

B<B<B<Null, O>, I>, I>:
- 从内到外：Null+O=0，B<Null,O>+I=01(1)，B<B<Null,O>,I>+I=011(3)
- 表示3
D<B<B<B<Null, O>, I>, I>, B<B<Null, I>, O>>:
- 整数部分：011(3)
- 指数部分：B<B<Null,I>,O>=10(-2)
- 表示3 × 10⁻² = 0.03

这种类型级编程技术在Rust中常用于在编译期进行复杂的类型计算和验证，常见于嵌入式开发、数学库和高安全性应用中。