一、源码

这段代码实现了一个类型级别的整数比较系统，允许在编译时进行整数比较操作。它定义了一套类型来表示比较结果，并为不同类型的整数实现了比较逻辑。

use core::cmp::Ordering;
use core::default::Default;
use crate::sealed::Sealed;
use crate::number::{Z0, P1, N1, B0, B1, NonZero};
///类型级比较,仅考虑类型级整数比较//-------------基本定义-------------------------------------------------
// 比较结果类型别名
pub type Equal = Z0;   // 相等
pub type Less = N1;    // 小于
pub type Greater = P1; // 大于/// 标记特征(trait)，用于比较结果类型：`Greater`、`Equal` 和 `Less`
pub trait Ord: Sealed {/// 将类型转换为运行时的 `Ordering` 值fn to_ordering() -> Ordering;
}impl Ord for Greater {#[inline]fn to_ordering() -> Ordering {Ordering::Greater  // 返回"大于"的比较结果}
}impl Ord for Less {#[inline]fn to_ordering() -> Ordering {Ordering::Less  // 返回"小于"的比较结果}
}impl Ord for Equal {#[inline]fn to_ordering() -> Ordering {Ordering::Equal  // 返回"等于"的比较结果}
}/// 类型比较运算符，用于比较 `Self` 和 `Rhs` 类型。
/// 类似于 [`core::cmp::Ord::cmp`] 但用于类型比较。
///
/// # 示例
/// ```rust
/// use unitrix::number::{Cmp, Ord, N1, Z0, P1};
/// use std::cmp::Ordering;
///
/// assert_eq!(<Z0 as Cmp<N1>>::Output::to_ordering(), Ordering::Greater);
/// assert_eq!(<Z0 as Cmp<Z0>>::Output::to_ordering(), Ordering::Equal);
/// assert_eq!(<Z0 as Cmp<P1>>::Output::to_ordering(), Ordering::Less);
/// ```
pub trait Cmp<Rhs = Self> {/// 比较结果的类型（只能是 `Greater`、`Less` 或 `Equal` 之一）type Output;#[doc(hidden)]  // 隐藏内部实现fn compare(self, rhs: Rhs) -> Self::Output;
}//---------------------bit 相对独立，集中保存bit.rs文件---------------------------------//---------------------Special 未来改为错误处理，不实现比较---------------------------------//---------------------Z0比较All---------------------------------
/// 0 == 0
impl Cmp<Z0> for Z0 {type Output = Equal;#[inline]fn compare(self, _: Z0) -> Self::Output {Equal::new()}
}/// 0 < 1
impl Cmp<P1> for Z0 {type Output = Less;#[inline]fn compare(self, _: P1) -> Self::Output {Less::new()}
}/// 0 > -1
impl Cmp<N1> for Z0 {type Output = Greater;#[inline]fn compare(self, _: N1) -> Self::Output {Greater::new()}
}/// 0 <==> B0<H>
impl<H: NonZero + Default> Cmp<B0<H>> for Z0
whereZ0: Cmp<H>,
{type Output = <Z0 as Cmp<H>>::Output;#[inline]fn compare(self, _: B0<H>) -> Self::Output {let _h = H::default();<Z0 as Cmp<H>>::compare(self, _h)}
}/// 0 <==> B1<H>
impl<H: NonZero + Default> Cmp<B1<H>> for Z0
whereZ0: Cmp<H>,
{type Output = <Z0 as Cmp<H>>::Output;#[inline]fn compare(self, _: B1<H>) -> Self::Output {let _h = H::default();<Z0 as Cmp<H>>::compare(self, _h)}
}//---------------------P1比较All---------------------------------
//---------------------P1比较All---------------------------------
/// 1 > 0
impl Cmp<Z0> for P1 {type Output = Greater;#[inline]fn compare(self, _: Z0) -> Self::Output {Greater::new()}
}/// 1 == 1
impl Cmp<P1> for P1 {type Output = Equal;#[inline]fn compare(self, _: P1) -> Self::Output {Equal::new()}
}/// 1 > -1
impl Cmp<N1> for P1 {type Output = Greater;#[inline]fn compare(self, _: N1) -> Self::Output {Greater::new()}
}/// P1 <==> B0<H>
impl<H: NonZero + Default> Cmp<B0<H>> for P1
whereZ0: Cmp<H>,
{type Output = <Z0 as Cmp<H>>::Output;#[inline]fn compare(self, _: B0<H>) -> Self::Output {let _h = H::default();<Z0 as Cmp<H>>::compare(Z0::new(), _h)}
}/// P1 <==> B1<H>
impl<H: NonZero + Default> Cmp<B1<H>> for P1
whereZ0: Cmp<H>,
{type Output = <Z0 as Cmp<H>>::Output;#[inline]fn compare(self, _: B1<H>) -> Self::Output {let _h = H::default();<Z0 as Cmp<H>>::compare(Z0::new(), _h)}
}//---------------------N1比较All---------------------------------
/// -1 < 0
impl Cmp<Z0> for N1 {type Output = Less;#[inline]fn compare(self, _: Z0) -> Self::Output {Less::new()}
}/// -1 < 1
impl Cmp<P1> for N1 {type Output = Less;#[inline]fn compare(self, _: P1) -> Self::Output {Less::new()}
}/// -1 == -1
impl Cmp<N1> for N1 {type Output = Equal;#[inline]fn compare(self, _: N1) -> Self::Output {Equal::new()}
}/// N1 <==> B0<H>
impl<H: NonZero + Default> Cmp<B0<H>> for N1
whereZ0: Cmp<H>,
{type Output = <Z0 as Cmp<H>>::Output;#[inline]fn compare(self, _: B0<H>) -> Self::Output {let _h = H::default();<Z0 as Cmp<H>>::compare(Z0::new(), _h)}
}/// N1 <==> B1<H>
impl<H: NonZero + Default> Cmp<B1<H>> for N1
whereZ0: Cmp<H>,
{type Output = <Z0 as Cmp<H>>::Output;#[inline]fn compare(self, _: B1<H>) -> Self::Output {let _h = H::default();<Z0 as Cmp<H>>::compare(Z0::new(), _h)}
}//---------------------B0<H>比较All---------------------------------/// B0<H> vs Z0: 比较H与Z0
impl<H: NonZero + Default> Cmp<Z0> for B0<H>
whereH: Cmp<Z0>,
{type Output = <H as Cmp<Z0>>::Output;#[inline]fn compare(self, _: Z0) -> Self::Output {let _h = H::default();<H as Cmp<Z0>>::compare(_h, Z0::new())}
}/// B0<H> vs P1: 比较H与Z0
impl<H: NonZero + Default> Cmp<P1> for B0<H>
whereH: Cmp<Z0>,
{type Output = <H as Cmp<Z0>>::Output;#[inline]fn compare(self, _: P1) -> Self::Output {let _h = H::default();<H as Cmp<Z0>>::compare(_h, Z0)}
}/// B0<H> vs N1: 比较H与Z0 
impl<H: NonZero + Default> Cmp<N1> for B0<H>
whereH: Cmp<Z0>,
{type Output = <H as Cmp<Z0>>::Output;#[inline]fn compare(self, _: N1) -> Self::Output {let _h = H::default();<H as Cmp<Z0>>::compare(_h, Z0)}
}/// B0<H1> vs B0<H2>: 比较H1与H2
impl<H1: NonZero + Default, H2: NonZero + Default> Cmp<B0<H2>> for B0<H1>
whereH1: Cmp<H2>,
{type Output = <H1 as Cmp<H2>>::Output;#[inline]fn compare(self, _: B0<H2>) -> Self::Output {let _h1 = H1::default();let _h2 = H2::default();<H1 as Cmp<H2>>::compare(_h1, _h2)}
}/// B0<H1> vs B1<H2>: 先比较H1与H2，如果相等则B1>B0
impl<H1: NonZero + Default, H2: NonZero + Default> Cmp<B1<H2>> for B0<H1>
whereH1: Cmp<H2>,<H1 as Cmp<H2>>::Output: IfLess,<<H1 as Cmp<H2>>::Output as IfLess>::Output:Default,
{type Output = <<H1 as Cmp<H2>>::Output as IfLess>::Output;#[inline]fn compare(self, _: B1<H2>) -> Self::Output {Self::Output::default()}
}// 辅助类型用于处理比较结果
pub trait IfLess {type Output;fn less() -> Self::Output;
}impl IfLess for Equal {type Output = Less;fn less() -> Self::Output{Less::new()}
}impl IfLess for Less {type Output = Less;fn less() -> Self::Output{Less::new()}
}impl IfLess for Greater {type Output = Greater;fn less() -> Self::Output{Greater::new()}
}//---------------------B1<H>比较All---------------------------------/// B1<H> vs Z0: 比较H与Z0
impl<H: NonZero + Default> Cmp<Z0> for B1<H>
whereH: Cmp<Z0>,
{type Output = <H as Cmp<Z0>>::Output;#[inline]fn compare(self, _: Z0) -> Self::Output {let _h = H::default();<H as Cmp<Z0>>::compare(_h, Z0)}
}/// B1<H> vs P1: 比较H与Z0
impl<H: NonZero + Default> Cmp<P1> for B1<H>
whereH: Cmp<Z0>,
{type Output = <H as Cmp<Z0>>::Output;#[inline]fn compare(self, _: P1) -> Self::Output {let _h = H::default();<H as Cmp<Z0>>::compare(_h, Z0)}
}/// B1<H> vs N1: 比较H与Z0
impl<H: NonZero + Default> Cmp<N1> for B1<H>
whereH: Cmp<Z0>,
{type Output = <H as Cmp<Z0>>::Output;#[inline]fn compare(self, _: N1) -> Self::Output {let _h = H::default();<H as Cmp<Z0>>::compare(_h, Z0)}
}/// B1<H1> vs B0<H2>: 先比较H1与H2，如果相等则B1>B0
impl<H1: NonZero + Default, H2: NonZero + Default> Cmp<B0<H2>> for B1<H1>
whereH1: Cmp<H2>,<H1 as Cmp<H2>>::Output: IfGreater,<<H1 as Cmp<H2>>::Output as IfGreater>::Output: Default,
{type Output = <<H1 as Cmp<H2>>::Output as IfGreater>::Output;#[inline]fn compare(self, _: B0<H2>) -> Self::Output {Self::Output::default()}
}/// B1<H1> vs B1<H2>: 比较H1与H2
impl<H1: NonZero + Default, H2: NonZero + Default> Cmp<B1<H2>> for B1<H1>
whereH1: Cmp<H2>,
{type Output = <H1 as Cmp<H2>>::Output;#[inline]fn compare(self, _: B1<H2>) -> Self::Output {let _h1 = H1::default();let _h2 = H2::default();<H1 as Cmp<H2>>::compare(_h1, _h2)}
}// 新增辅助trait用于处理B1>B0的情况
pub trait IfGreater {type Output;fn greater() -> Self::Output;
}impl IfGreater for Equal {type Output = Greater;fn greater() -> Self::Output {Greater::new()}
}impl IfGreater for Less {type Output = Less;fn greater() -> Self::Output {Less::new()}
}impl IfGreater for Greater {type Output = Greater;fn greater() -> Self::Output {Greater::new()}
}

二、核心组件

1. 比较结果类型

   • Equal (Z0): 表示相等

   • Less (N1): 表示小于

   • Greater (P1): 表示大于

2. 主要特征(trait)

   • Ord: 标记特征，用于比较结果类型，可以将类型转换为运行时的 Ordering 值

   • Cmp: 类型比较运算符，类似于 core::cmp::Ord::cmp 但用于类型比较

三、实现细节

基本类型比较

代码为基本类型实现了相互比较：

• Z0 (零)

• P1 (正一)

• N1 (负一)

例如：

// 0 == 0
impl Cmp<Z0> for Z0 {type Output = Equal;// ...
}// 0 < 1
impl Cmp<P1> for Z0 {type Output = Less;// ...
}

二进制数比较

代码还处理了二进制数类型 B0 和 B1 的比较，其中 H 是高位部分：

• B0 表示二进制数以0结尾的数

• B1 表示二进制数以1结尾的数

比较规则：

1. 当比较 B0 和 B1 时，先比较高位数 H，如果相等则 B1 大于 B0

2. 其他情况直接比较高位数

辅助特征

• IfLess: 处理 B0

  与 B1

  比较时的逻辑

• IfGreater: 处理 B1

  与 B0

  比较时的逻辑

四、使用示例

···rust

use unitrix::number::{Cmp, Ord, N1, Z0, P1};
use std::cmp::Ordering;

assert_eq!(<Z0 as Cmp>::Output::to_ordering(), Ordering::Greater);
assert_eq!(<Z0 as Cmp>::Output::to_ordering(), Ordering::Equal);
assert_eq!(<Z0 as Cmp>::Output::to_ordering(), Ordering::Less);

### 五、总结这段代码实现了一个编译时的类型级整数比较系统，通过Rust的类型系统在编译期完成整数比较操作，避免了运行时开销。它支持基本整数和二进制表示的数字之间的比较，并提供了将比较结果转换为运行时 Ordering 值的能力。