一、源碼

這段代碼實現了一個類型級別的整數比較系統，允許在編譯時進行整數比較操作。它定義了一套類型來表示比較結果，并為不同類型的整數實現了比較邏輯。

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 值的能力。