• 確定性：必定存在>或==或<其中的一個關系；

6.3 trait定義

1. PartialOrd trait

// 二元關系定義（<,==,>）
pub enum Ordering {
    Less = -1,
    Equal = 0,
    Greater = 1,
}

pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
    fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;
    fn lt(&self, other: &Rhs) -> bool {
        matches!(self.partial_cmp(other), Some(Less))
    }
    fn le(&self, other: &Rhs) -> bool {
        matches!(self.partial_cmp(other), Some(Less | Equal))
    }
    fn gt(&self, other: &Rhs) -> bool {
        matches!(self.partial_cmp(other), Some(Greater))
    }
    fn ge(&self, other: &Rhs) -> bool {
        matches!(self.partial_cmp(other), Some(Greater | Equal))
    }
}

基本信息：

0. PartialOrd繼承自PartialEq，這很好理解，無法比較大小的類型也一定不能進行相等性比較；

1. 提供partial_cmp()方法用于主類型和可以是其他類型的參數比較，返回的Option，表示兩者關系可以是無法比較的（None），那么這里我們就可以聯想到Ord trait返回的肯定是Ordering（因為具有全序的類型不會存在無法比較的情況）；

2. 另外四個方法分別實現了對應的操作符:<,<=,>,>=，即實現了PartialOrd的類型可以使用這些操作符進行比較；除此之外，由于繼承了PartialEq，所以還允許使用==,!=；

請再次記住，不管是PartialOrd還是Ord，都包含相等關系。

2. Ord trait

pub trait Ord: Eq + PartialOrd<Self> {
    // 方法1
    fn cmp(&self, other: &Self) -> Ordering;

    // 方法2
    fn max(self, other: Self) -> Self
        where
            Self: Sized,
            Self: ~ const Destruct,
    {
        // HACK(fee1-dead): go back to using `self.max_by(other, Ord::cmp)`
        // when trait methods are allowed to be used when a const closure is
        // expected.
        match self.cmp(&other) {
            Ordering::Less | Ordering::Equal => other,
            Ordering::Greater => self,
        }
    }

    // 方法3
    fn min(self, other: Self) -> Self
        where
            Self: Sized,
            Self: ~ const Destruct,
    {
        // HACK(fee1-dead): go back to using `self.min_by(other, Ord::cmp)`
        // when trait methods are allowed to be used when a const closure is
        // expected.
        match self.cmp(&other) {
            Ordering::Less | Ordering::Equal => self,
            Ordering::Greater => other,
        }
    }

    // 方法4
    fn clamp(self, min: Self, max: Self) -> Self
        where
            Self: Sized,
            Self: ~ const Destruct,
            Self: ~ const PartialOrd,
    {
        assert!(min <= max);
        if self < min {
            min
        } else if self > max {
            max
        } else {
            self
        }
    }
}

基本信息：

0. cmp方法用于比較self與參數other的二元關系，返回Ordering類型（區別于PartialOrd.partial_cmp()返回的Option）；

1. Ord繼承自Eq+PartialOrd，這也很好理解，具有全序關系的類型自然具有偏序關系；

2. 提供min/max()方法以返回self與參數other之間的較小值/較大值；

3. 額外提供clamp()方法返回輸入的參數區間內的值；

4. 顯然，由于繼承了PartialOrd，所以實現了Ord的類型可以使用操作符<,<=,>,>=,==,!=；

對Self: ~ const Destruct的解釋：位于where后即是類型約束，這里約束了Self類型必須是實現了Destructtrait的一個指向常量的裸指針。

全序和偏序的概念（來自離散數學）

• 全序：即全序關系，自然也是一種二元關系。全序是指，集合中的任兩個元素之間都可以比較的關系。比如實數中的任兩個數都可以比較大小，那么“大小”就是實數集的一個全序關系。

• 偏序：集合中只有部分元素之間可以比較的關系。比如復數集中并不是所有的數都可以比較大小，那么“大小”就是復數集的一個偏序關系。

• 顯然，全序關系必是偏序關系。反之不成立。

6.4 可派生

1. PartialOrd derive

PartialOrd和Ord也是可以使用derive宏進行自動實現的，代碼如下：

#[derive(PartialOrd, PartialEq)]
struct Book {
    name: String,
}

#[derive(PartialOrd, PartialEq)]
enum BookFormat { Paperback, Hardback, Ebook }

這里有幾點需要注意：

0. 由于繼承關系，所以必須同時派生PartialEq；

1. 與PartialEq相比，不支持為union類型派生；

2. 對struct進行派生時，大小順序依據的是成員字段的字典序（字母表中的順序，數字與字母比較則根據ASCII表編碼，數字編碼<字母編碼；若比較多字節字符如中文，則轉Unicode編碼后再比較; 實際上ASCII表中的字符編碼與對應Unicode編碼一致）；

3. 對enum進行派生時，大小順序依據的是枚舉類型的值大小，默認情況下，第一個枚舉類型的值是1，向下遞增1，所以第一個枚舉最小；

下面使用代碼對第2，3點舉例說明：

#[derive(PartialOrd, PartialEq)]
struct Book {
    name: String,
}
assert!(Book { name: "a".to_string() } < Book { name: "b".to_string() });
assert!(Book { name: "b".to_string() } < Book { name: "c".to_string() });
// 字典序中，數字<字母（按ASCII編碼排序）
assert!(Book { name: "1".to_string() } < Book { name: "2".to_string() });
assert!(Book { name: "2".to_string() } < Book { name: "a".to_string() });
// 字典序中，如果比較多字節字符，則先轉為其Unicode的十六進制形式，然后逐字節比較
// 比如 中文 "曜" 和 "耀" 的Unicode編碼分別為0x66DC和0x8000，所以前者小于后者
assert_eq!("曜", "u{66dc}");
assert_eq!("耀", "u{8000}");
assert!(Book { name: "曜".to_string() } < Book { name: "耀".to_string() });

#[derive(PartialOrd, PartialEq)]
enum BookFormat {
    Paperback,
    // 1
    Hardback,
    // 2
    Ebook,     // 3
}
assert!(BookFormat::Paperback < BookFormat::Hardback);
assert!(BookFormat::Hardback < BookFormat::Ebook);

#[derive(PartialOrd, PartialEq)]
enum BookFormat2 {
    // 手動指定枚舉的值，則可以改變它們的大小順序
    Paperback = 3,
    Hardback = 2,
    Ebook = 1,
}
assert!(BookFormat2::Paperback > BookFormat2::Hardback);
assert!(BookFormat2::Hardback > BookFormat2::Ebook);

對于字典序比較規則，還有一些特殊情況，如下：

• 如果元素A是元素B的前綴，則元素A<元素B；

• 空字符序列<非空字序列；

2. Ord derive

 #[derive(Ord, Eq, PartialOrd, PartialEq)]
struct Book {
    name: String,
}

#[derive(Ord, Eq, PartialOrd, PartialEq)]
enum BookFormat {
    Paperback,
    Hardback,
    Ebook,
}

這里只需注意一點，那就是由于繼承關系，Ord需要和Eq, PartialOrd, PartialEq同時派生。另外，根據前面所提到的，PartialOrd和Ord都支持>=,<=，這個要記得；

6.5 手動實現PartialOrd和Ord

1. PartialOrd Impl

// 注意這里測試對象是Book3，不要為成員字段format即BookFormat3派生任何trait，模擬實際項目中無法修改成員字段特性的情況
enum BookFormat3 {
    Paperback,
    Hardback,
    Ebook,
}

struct Book3 {
    name: String,
    format: BookFormat3,
}

// -- 先得實現 PartialEq
impl PartialEq<Self> for Book3 {
    // tips：這里可以將省略
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name
        // 這里假設format字段不要求比較
    }
}

// -- 才能實現 PartialOrd
impl PartialOrd for Book3 {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        // 直接調用name(String)的比較方法，如果成員字段也沒有實現PartialOrd，那就得先為成員實現，這類情況很少
        self.name.partial_cmp(&other.name)
    }
}

2. Ord Impl

// 測試對象：Book3
// - 這里同樣沒有使用任何derive，全手動實現，由于繼承關系，需要實現四個trait
// - 注意：若存在任一成員字段(這里指   format字段)未實現PartialEq/Eq/PartialOrd，都是無法為Book3派生Ord的（派生時不會解析下面的手動impl）
enum BookFormat3 {
    Paperback,
    Hardback,
    Ebook,
}

struct Book3 {
    name: String,
    format: BookFormat3,
}

// -- 先實現 PartialEq
impl PartialEq for Book3 {
    fn eq(&self, other: &Book3) -> bool {
        self.name == other.name
        // 這里假設format字段不要求比較
    }
}

// -- 再實現 Eq
impl Eq for Book3 {}

// -- 再實現 Ord
impl Ord for Book3 {
    fn cmp(&self, other: &Book3) -> Ordering {
        // 直接調用name(String)的cmp方法（當需要實現Ord時，成員字段一般都實現了Ord，可直接調用其cmp方法）
        self.name.cmp(&other.name)
    }
}

// -- 最后實現 PartialOrd
impl PartialOrd for Book3 {
    fn partial_cmp(&self, other: &Book3) -> Option<Ordering> {
        // 直接調用上面實現的cmp方法
        Some(self.cmp(&other))
    }
}

閱讀此代碼需要注意幾點：

0. 先讀完代碼注釋；

1. 請注意是先實現Ord，再實現PartialOrd，理由是既然一開始就想要為類型實現Ord，說明類型是能夠得出一個肯定結果的（非None），所以后實現PartialOrd直接調用Ord的cmp()；

6.6 比較不同的類型

這一節不貼代碼了，留給讀者去實現。具體實現手法可參考前面3.5節或4.5節中的內容。

6.7 Rust基本類型如何實現PartialOrd和Ord

1. PartialOrd impl macro

我們以前面介紹過的同樣的方式找到cmp.rs中PartialOrd的實現宏，代碼如下：

mod impls {
    // ... 前面是PartialEq和Eq的宏實現

    macro_rules! partial_ord_impl {
        ($($t:ty)*) => ($(
            #[stable(feature = "rust1", since = "1.0.0")]
            #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
            impl const PartialOrd for $t {
                #[inline]
                fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
                   // 注意看，此處是根據兩個比較結果來得到最終結果，本質上是要求比較的值滿足對立性（浮點數NaN不滿足，所以返回None）
                    match (*self <= *other, *self >= *other) {
                        (false, false) => None,
                        (false, true) => Some(Greater),
                        (true, false) => Some(Less),
                        (true, true) => Some(Equal),
                    }
                }
                #[inline]
                fn lt(&self, other: &$t) -> bool { (*self) < (*other) }
                #[inline]
                fn le(&self, other: &$t) -> bool { (*self) <= (*other) }
                #[inline]
                fn ge(&self, other: &$t) -> bool { (*self) >= (*other) }
                #[inline]
                fn gt(&self, other: &$t) -> bool { (*self) > (*other) }
            }
        )*)
    }

    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
    impl const PartialOrd for () {
        #[inline]
        fn partial_cmp(&self, _: &()) -> Option<Ordering> {
            Some(Equal)
        }
    }

    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
    impl const PartialOrd for bool {
        #[inline]
        fn partial_cmp(&self, other: &bool) -> Option<Ordering> {
            Some(self.cmp(other))
        }
    }

    partial_ord_impl! { f32 f64 }
}

這里要注意一下幾點：

0. 代碼中定義的宏partial_ord_impl!是通過兩個比較結果來得到最終結果（看注釋）；

1. 這個宏除了應用在了浮點數類型上，還應用在了()和bool類型。浮點數類型不必多說，單元類型是一種單值類型用于排序的情況也比較少，為bool類型實現這個trait的原因是：有時我們需要對包含bool類型成員的struct或enum進行排序，所以需要為其實現PartialOrd（注意其實現也是調用self.cmp()）；

這里的impl const中的const關鍵字意味著標記這個trait實現是編譯時常量（編譯時優化），以保證運行時不會有額外開銷。這里是因為fn partial_cmp()的實現沒有修改任何數據才可以加const，當然還有其他要求例如不能使用動態分配的內存（例如 Box 或 Vec）、不能調用非 const 函數等；

2. Ord impl macro

mod impls {
    // ... 前面是PartialEq/Eq/PartialOrd的宏實現

    macro_rules! ord_impl {
        ($($t:ty)*) => ($(
            #[stable(feature = "rust1", since = "1.0.0")]
            #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
            impl const PartialOrd for $t {
                #[inline]
                fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
                    Some(self.cmp(other))
                }
                #[inline]
                fn lt(&self, other: &$t) -> bool { (*self) < (*other) }
                #[inline]
                fn le(&self, other: &$t) -> bool { (*self) <= (*other) }
                #[inline]
                fn ge(&self, other: &$t) -> bool { (*self) >= (*other) }
                #[inline]
                fn gt(&self, other: &$t) -> bool { (*self) > (*other) }
            }

            #[stable(feature = "rust1", since = "1.0.0")]
            #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
            impl const Ord for $t {
                #[inline]
                fn cmp(&self, other: &$t) -> Ordering {
                    // The order here is important to generate more optimal assembly.
                    // See  for more info.
                    if *self < *other { Less }
                    else if *self == *other { Equal }
                    else { Greater }
                }
            }
        )*)
    }

    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
    impl const Ord for () {
        #[inline]
        fn cmp(&self, _other: &()) -> Ordering {
            Equal
        }
    }

    #[stable(feature = "rust1", since = "1.0.0")]
    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
    impl const Ord for bool {
        #[inline]
        fn cmp(&self, other: &bool) -> Ordering {
            // Casting to i8's and converting the difference to an Ordering generates
            // more optimal assembly.
            // See  for more info.
            match (*self as i8) - (*other as i8) {
                -1 => Less,
                0 => Equal,
                1 => Greater,
                // SAFETY: bool as i8 returns 0 or 1, so the difference can't be anything else
                _ => unsafe { unreachable_unchecked() },
            }
        }
    }

    ord_impl! { char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
}

這里需要了解一下幾點：

0. 實現Ord的時候需要同時實現PartialOrd，不要求實現的順序。PartialOrd的partial_cmp()內部調用的是Ord的cmp()，理由前面講過；

1. 同樣為()和bool類型實現了Ord；

2. 為大部分基本類型char usize u8 u16 ...(除了f32、f64) 實現了Ord；

6.8 為其他類型實現四大compare-trait

這里指的其他類型是!、不可變借用類型、可變借用類型，具體實現代碼就在源碼中剛剛看的宏ord_impl!下方，此處就不再贅述。