【PhysUnits】15.16 补充to_i32方法的类型级整数表示(basic.rs)

一、源码

这段代码实现了一个类型级别的整数系统，使用Rust的类型系统来表示和操作整数。这种技术在依赖类型编程和类型安全API设计中很有用。

use crate::sealed::Sealed;
use core::marker::PhantomData;

// ========== 基础类型定义 ==========
#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct B0<H>(pub PhantomData<H>);

#[derive(Eq, PartialEq, Clone, Copy, Debug)]
pub struct B1<H>(pub PhantomData<H>);

#[derive(Eq, PartialEq, Clone, Copy, Debug, Default)]
pub struct Z0;

#[derive(Eq, PartialEq, Clone, Copy, Debug, Default)]
pub struct P1;//新增

#[derive(Eq, PartialEq, Clone, Copy, Debug, Default)]
pub struct N1;

impl<H> Default for B0<H>{
    fn default() -> Self{
        B0(PhantomData)
    }
}

impl<H> Default for B1<H>{
    fn default() -> Self{
        B1(PhantomData)
    }
}

// ========== Sealed 实现 ==========
impl<H> Sealed for B0<H> {}
impl<H> Sealed for B1<H> {}
impl Sealed for Z0 {}
impl Sealed for P1 {}
impl Sealed for N1 {}

// ========== 标记特质定义 ==========
pub trait Integer: Default+Sealed + Copy + Default + 'static {
    fn to_i32(&self) -> i32;//新补充的方法
}
pub trait NonZero: Integer {}
pub trait NonOne: Integer {}
pub trait NonNegOne: Integer {}
pub trait Unsigned: Integer {}

// ========== NonZero 实现 ==========
impl NonZero for P1 {}
impl NonZero for N1 {}
impl<H: NonZero> NonZero for B0<H> {}
impl<H: NonZero> NonZero for B1<H> {}

// ========== Integer 实现 ==========
// Z0 表示 0
impl Integer for Z0 {
    #[inline(always)]
    fn to_i32(&self) -> i32 {
        0
    }
}

// P1 表示 +1
impl Integer for P1 {
    #[inline(always)]
    fn to_i32(&self) -> i32 {
        1
    }
}

// N1 表示 -1
impl Integer for N1 {
    #[inline(always)]
    fn to_i32(&self) -> i32 {
        -1
    }
}

// B0 表示 H * 2
impl<H: NonZero> Integer for B0<H> {
    #[inline(always)]
    fn to_i32(&self) -> i32 {
        H::default().to_i32() * 2
    }
}

// B1 表示 H * 2 + 1
impl<H: NonZero> Integer for B1<H> {
    #[inline(always)]
    fn to_i32(&self) -> i32 {
        H::default().to_i32() * 2 + 1
    }
}

// ========== NonOne 实现 ==========
impl NonOne for Z0 {}
impl NonOne for N1 {}
impl<H: NonZero> NonOne for B0<H> {}
impl<H: NonZero> NonOne for B1<H> {}

// ========== NonNegOne 实现 ==========
impl NonNegOne for Z0 {}
impl NonNegOne for P1 {}
impl<H: NonZero> NonNegOne for B0<H> {}
impl<H: NonZero> NonNegOne for B1<H> {}

// ========== Unsigned 实现 ==========
impl Unsigned for Z0 {}
impl Unsigned for P1 {}
impl<H: NonZero + NonNegOne> Unsigned for B0<H> {}
impl<H: NonZero + NonNegOne> Unsigned for B1<H> {}

// ========== 构造函数 ==========
impl<H> B0<H> {
    #[inline]
    pub fn new() -> Self {
        B0(PhantomData)
    }
}

impl<H> B1<H> {
    #[inline]
    pub fn new() -> Self {
        B1(PhantomData)
    }
}

impl P1 {
    #[inline]
    pub fn new() -> Self {
        P1
    }
}

impl N1 {
    #[inline]
    pub fn new() -> Self {
        N1
    }
}

impl Z0 {
    #[inline]
    pub fn new() -> Self {
        Z0
    }
}

二、基础类型定义

1. 二进制位类型：

• B0: 表示一个以0结尾的二进制数，H是更高位

• B1: 表示一个以1结尾的二进制数，H是更高位

2. 基本数值类型：

• Z0: 表示数字0

• P1: 表示数字+1 (新增)

• N1: 表示数字-1

这些类型都使用了PhantomData来保持类型参数而不需要实际值，并实现了常见的trait如Eq, PartialEq, Clone, Copy, Debug等。

三、特质(Trait)系统

1. Integer特质:

• 所有整数类型的基特质

• 要求实现Default, Sealed, Copy等

• 新增了to_i32()方法将类型级整数转换为运行时值

2. 子特质:

• NonZero: 非零数

• NonOne: 非一数

• NonNegOne: 非负一数

• Unsigned: 无符号数

四、数值表示规则

• Z0 = 0

• P1 = +1

• N1 = -1

• B0 = H * 2

• B1 = H * 2 + 1

例如：

• B1 表示 P1 * 2 = 2 (B0) 然后 2 * 2 + 1 = 5 (B1)

五、特质实现

代码为各种组合实现了适当的特质：

• 非零数(NonZero)包括所有除了Z0的数

• 非一数(NonOne)包括所有除了P1的数

• 无符号数(Unsigned)包括所有非负数

六、构造函数

为每种类型提供了new()构造函数，方便创建实例。

七、使用场景

这种类型级整数系统可以用于:

• 类型安全的状态机

• 维度检查

• 编译时计算

• 确保某些值在编译时满足特定条件(如非零、正数等)

通过这种方式，可以在编译时捕获更多错误，而不需要运行时检查。