【PhysUnits】4.1 类型级比特位实现解释（boolean.rs）

一、源码

该代码实现了一个类型级(type-level)的布尔系统，允许在编译时进行布尔运算。

//! 类型级比特位实现
//!
//! 这些是基础的比特位类型，作为本库中其他数值类型的构建基础
//!
//! 已实现的**类型运算符**：
//!
//! - 来自 `core::ops` 的：`BitAnd`(与), `BitOr`(或), `BitXor`(异或) 和 `Not`(非)
//! - 比较操作：`PartialEq`, `Eq`
//! - 转换操作：`From<bool>`, `Into<bool>`
//!
//! 别名定义：
//! - `B1` = `True` (逻辑真/正一)
//! - `B0` = `False` (逻辑假/零)
//!
//! 示例：
//! ```
//! use your_crate::{B1, B0, Boolean};
//!
//! let t = B1::new();
//! let f = B0::new();
//!
//! assert_eq!(t & t, B1);
//! assert_eq!(t | f, B1);
//! assert_eq!(t ^ t, B0);
//! assert_eq!(!t, B0);
//! ```use core::ops::{BitAnd, BitOr, BitXor, Not};
use crate::sealed::Sealed;/// 编译时比特位的标记特征
///
/// 这个 trait 定义了类型级布尔值的基本操作和行为，
/// 包括构造、转换和常量值访问。
pub trait Boolean: Sealed + Copy + Default + 'static {/// 布尔值的编译时常量表示const BOOL: bool;/// 创建一个该类型的新实例fn new() -> Self;/// 将类型级布尔值转换为运行时布尔值fn to_bool() -> bool {Self::BOOL}/// 获取当前实例对应的运行时布尔值fn as_bool(&self) -> bool {Self::BOOL}
}/// 类型级比特位0（逻辑假）
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug, Default)]
pub struct False;// 类型级比特位0的别名（零） zero.rs文件实现
//pub type B0 = False;impl False {/// 创建一个新的 `False` 实例#[inline(always)]pub const fn new() -> Self {False}
}/// 类型级比特位1（逻辑真）
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug, Default)]
pub struct True;/// 类型级比特位1的别名（正一）
pub type B1 = True;impl True {/// 创建一个新的 `True` 实例#[inline(always)]pub const fn new() -> Self {True}
}// 为布尔类型实现密封标记
impl Sealed for False {}
impl Sealed for True {}impl Boolean for False {const BOOL: bool = false;#[inline(always)] fn new() -> Self { Self }
}impl Boolean for True {const BOOL: bool = true;#[inline(always)] fn new() -> Self { Self }
}// 实现所有逻辑运算/// 实现逻辑非运算
impl Not for False {type Output = True;#[inline(always)]fn not(self) -> Self::Output {True}
}impl Not for True {type Output = False;#[inline(always)]fn not(self) -> Self::Output {False}
}/// 实现逻辑与运算
impl<Rhs: Boolean> BitAnd<Rhs> for False {type Output = Self;#[inline(always)]fn bitand(self, _: Rhs) -> Self::Output {Self}
}impl BitAnd<False> for True {type Output = False;#[inline(always)]fn bitand(self, _: False) -> Self::Output {False}
}impl BitAnd<True> for True {type Output = True;#[inline(always)]fn bitand(self, _: True) -> Self::Output {True}
}/// 实现逻辑或运算
impl BitOr<False> for False {type Output = False;#[inline(always)]fn bitor(self, _: False) -> Self::Output {False}
}impl BitOr<True> for False {type Output = True;#[inline(always)]fn bitor(self, _: True) -> Self::Output {True}
}impl<Rhs: Boolean> BitOr<Rhs> for True {type Output = True;#[inline(always)]fn bitor(self, _: Rhs) -> Self::Output {True}
}/// 实现逻辑异或运算
impl BitXor<False> for False {type Output = False;#[inline(always)]fn bitxor(self, _: False) -> Self::Output {False}
}impl BitXor<False> for True {type Output = True;#[inline(always)]fn bitxor(self, _: False) -> Self::Output {True}
}impl BitXor<True> for False {type Output = True;#[inline(always)]fn bitxor(self, _: True) -> Self::Output {True}
}impl BitXor<True> for True {type Output = False;#[inline(always)]fn bitxor(self, _: True) -> Self::Output {False}
}// 实现转换操作impl From<bool> for &'static dyn Boolean {/// 从运行时布尔值创建类型级布尔值的引用fn from(b: bool) -> Self {if b { &True } else { &False }}
}impl From<bool> for True {/// 从 `true` 创建 `True` 实例////// # Panics/// 如果输入为 `false` 会 panicfn from(b: bool) -> Self {assert!(b);True}
}impl From<bool> for False {/// 从 `false` 创建 `False` 实例////// # Panics/// 如果输入为 `true` 会 panicfn from(b: bool) -> Self {assert!(!b);False}
}impl<T: Boolean> From<T> for bool {/// 将类型级布尔值转换为运行时布尔值fn from(b: T) -> Self {b.as_bool()}
}impl std::fmt::Display for dyn Boolean {/// 实现格式化输出，显示布尔值fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {write!(f, "{}", self.as_bool())}
}#[cfg(test)]
mod tests {use super::*;#[test]fn test_aliases() {let p1 = B1::new();let z0 = B0::new();assert_eq!(p1, True);assert_eq!(z0, False);assert!(B1::BOOL);assert!(!B0::BOOL);}#[test]fn test_boolean_ops_with_aliases() {let p1 = B1::new();let z0 = B0::new();assert_eq!(p1 & p1, B1);assert_eq!(p1 | z0, B1);assert_eq!(p1 ^ p1, B0);assert_eq!(!p1, B0);}#[test]fn test_boolean_ops() {let t = True::new();let f = False::new();assert_eq!(t & t, True);assert_eq!(t & f, False);assert_eq!(f & t, False);assert_eq!(f & f, False);assert_eq!(t | t, True);assert_eq!(t | f, True);assert_eq!(f | t, True);assert_eq!(f | f, False);assert_eq!(t ^ t, False);assert_eq!(t ^ f, True);assert_eq!(f ^ t, True);assert_eq!(f ^ f, False);assert_eq!(!t, False);assert_eq!(!f, True);}#[test]fn test_conversions() {let t: &dyn Boolean = true.into();assert!(t.as_bool());let f: &dyn Boolean = false.into();assert!(!f.as_bool());assert!(bool::from(True::new()));assert!(!bool::from(False::new()));}
}

二、主要组件

Boolean trait

定义了类型级布尔值的基本行为和操作
包含编译时常量BOOL表示布尔值
提供构造方法new()和转换方法to_bool()/as_bool()
标记为Sealed防止外部实现

布尔类型

False: 表示逻辑假/0
True: 表示逻辑真/1

类型别名:

B0 = False (零)

B1 = True (正一)

实现的操作

逻辑运算:
- Not(非): !
- BitAnd(与): &
- BitOr(或): |
- BitXor(异或): ^
比较: PartialEq, Eq
转换: From, Into

三、关键实现细节

常量值:

False::BOOL = false
True::BOOL = true

逻辑运算实现:

每种运算都为所有可能的组合提供了具体实现
例如True & False返回False

转换操作:

可以从运行时bool转换为类型级布尔值
也可以从类型级布尔值转换回运行时bool

性能优化:

使用#[inline(always)]确保零运行时开销
所有操作都在编译时完成

四、使用示例

use your_crate::{B1, B0};let t = B1::new();  // True
let f = B0::new();  // Falseassert_eq!(t & t, B1);  // True AND True = True
assert_eq!(t | f, B1);  // True OR False = True
assert_eq!(t ^ t, B0);  // True XOR True = False
assert_eq!(!t, B0);     // NOT True = False