std::cmp::Ord

Trait std::cmp::Ord

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

Trait for types that form a total order.

An order is a total order if it is (for all a, b and c):

• total and antisymmetric: exactly one of a < b, a == b or a > b is true; and
• transitive, a < b and b < c implies a < c. The same must hold for both == and >.

Derivable

This trait can be used with #[derive]. When derived, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct's members.

How can I implement Ord?

Ord requires that the type also be PartialOrd and Eq (which requires PartialEq).

Then you must define an implementation for cmp(). You may find it useful to use cmp() on your type's fields.

Here's an example where you want to sort people by height only, disregarding id and name:

use std::cmp::Ordering;

#[derive(Eq)]
struct Person {
    id: u32,
    name: String,
    height: u32,
}

impl Ord for Person {
    fn cmp(&self, other: &Person) -> Ordering {
        self.height.cmp(&other.height)
    }
}

impl PartialOrd for Person {
    fn partial_cmp(&self, other: &Person) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl PartialEq for Person {
    fn eq(&self, other: &Person) -> bool {
        self.height == other.height
    }
}

Required Methods

use std::cmp::Ordering;

assert_eq!(5.cmp(&10), Ordering::Less);
assert_eq!(10.cmp(&5), Ordering::Greater);
assert_eq!(5.cmp(&5), Ordering::Equal);

Implementors

• impl<K, V> Ord for BTreeMap<K, V> where
    K: Ord,
    V: Ord, 
• impl<'a, B> Ord for Cow<'a, B> where
    B: Ord + ToOwned + ?Sized, 
• impl<T> Ord for LinkedList<T> where
    T: Ord, 
• impl<T> Ord for Vec<T> where
    T: Ord, 
• impl<A> Ord for VecDeque<A> where
    A: Ord, 
• impl<T> Ord for BTreeSet<T> where
    T: Ord, 
• impl Ord for String
• impl<T> Ord for Box<T> where
    T: Ord + ?Sized, 
• impl<T> Ord for Arc<T> where
    T: Ord + ?Sized, 
• impl<T> Ord for Rc<T> where
    T: Ord + ?Sized, 
• impl<T> Ord for *const T where
    T: ?Sized, 
• impl<T> Ord for *mut T where
    T: ?Sized, 
• impl<T> Ord for Reverse<T> where
    T: Ord, 
• impl Ord for Ordering
• impl Ord for ()
• impl Ord for bool
• impl Ord for !
• impl<'a, A> Ord for &'a A where
    A: Ord + ?Sized, 
• impl<'a, A> Ord for &'a mut A where
    A: Ord + ?Sized, 
• impl<T> Ord for Cell<T> where
    T: Copy + Ord, 
• impl<T> Ord for RefCell<T> where
    T: Ord + ?Sized, 
• impl<T> Ord for [T] where
    T: Ord, 
• impl Ord for str
• impl<T> Ord for Wrapping<T> where
    T: Ord, 
• impl<T> Ord for NonZero<T> where
    T: Zeroable + Ord, 
• impl<Ret> Ord for fn() -> Ret
• impl<Ret> Ord for extern fn() -> Ret
• impl<Ret> Ord for unsafe fn() -> Ret
• impl<Ret> Ord for unsafe extern fn() -> Ret
• impl<Ret, A> Ord for fn(A) -> Ret
• impl<Ret, A> Ord for extern fn(A) -> Ret
• impl<Ret, A> Ord for extern fn(A, ...) -> Ret
• impl<Ret, A> Ord for unsafe fn(A) -> Ret
• impl<Ret, A> Ord for unsafe extern fn(A) -> Ret
• impl<Ret, A> Ord for unsafe extern fn(A, ...) -> Ret
• impl<Ret, A, B> Ord for fn(A, B) -> Ret
• impl<Ret, A, B> Ord for extern fn(A, B) -> Ret
• impl<Ret, A, B> Ord for extern fn(A, B, ...) -> Ret
• impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret
• impl<Ret, A, B> Ord for unsafe extern fn(A, B) -> Ret
• impl<Ret, A, B> Ord for unsafe extern fn(A, B, ...) -> Ret
• impl<Ret, A, B, C> Ord for fn(A, B, C) -> Ret
• impl<Ret, A, B, C> Ord for extern fn(A, B, C) -> Ret
• impl<Ret, A, B, C> Ord for extern fn(A, B, C, ...) -> Ret
• impl<Ret, A, B, C> Ord for unsafe fn(A, B, C) -> Ret
• impl<Ret, A, B, C> Ord for unsafe extern fn(A, B, C) -> Ret
• impl<Ret, A, B, C> Ord for unsafe extern fn(A, B, C, ...) -> Ret
• impl<Ret, A, B, C, D> Ord for fn(A, B, C, D) -> Ret
• impl<Ret, A, B, C, D> Ord for extern fn(A, B, C, D) -> Ret
• impl<Ret, A, B, C, D> Ord for extern fn(A, B, C, D, ...) -> Ret
• impl<Ret, A, B, C, D> Ord for unsafe fn(A, B, C, D) -> Ret
• impl<Ret, A, B, C, D> Ord for unsafe extern fn(A, B, C, D) -> Ret
• impl<Ret, A, B, C, D> Ord for unsafe extern fn(A, B, C, D, ...) -> Ret
• impl<Ret, A, B, C, D, E> Ord for fn(A, B, C, D, E) -> Ret
• impl<Ret, A, B, C, D, E> Ord for extern fn(A, B, C, D, E) -> Ret
• impl<Ret, A, B, C, D, E> Ord for extern fn(A, B, C, D, E, ...) -> Ret
• impl<Ret, A, B, C, D, E> Ord for unsafe fn(A, B, C, D, E) -> Ret
• impl<Ret, A, B, C, D, E> Ord for unsafe extern fn(A, B, C, D, E) -> Ret
• impl<Ret, A, B, C, D, E> Ord for unsafe extern fn(A, B, C, D, E, ...) -> Ret
• impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret
• impl<Ret, A, B, C, D, E, F> Ord for extern fn(A, B, C, D, E, F) -> Ret
• impl<Ret, A, B, C, D, E, F> Ord for extern fn(A, B, C, D, E, F, ...) -> Ret
• impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(A, B, C, D, E, F) -> Ret
• impl<Ret, A, B, C, D, E, F> Ord for unsafe extern fn(A, B, C, D, E, F) -> Ret
• impl<Ret, A, B, C, D, E, F> Ord for unsafe extern fn(A, B, C, D, E, F, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret
• impl<Ret, A, B, C, D, E, F, G> Ord for extern fn(A, B, C, D, E, F, G) -> Ret
• impl<Ret, A, B, C, D, E, F, G> Ord for extern fn(A, B, C, D, E, F, G, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G> Ord for unsafe fn(A, B, C, D, E, F, G) -> Ret
• impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern fn(A, B, C, D, E, F, G) -> Ret
• impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern fn(A, B, C, D, E, F, G, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H> Ord for fn(A, B, C, D, E, F, G, H) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H> Ord for extern fn(A, B, C, D, E, F, G, H) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H> Ord for extern fn(A, B, C, D, E, F, G, H, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern fn(A, B, C, D, E, F, G, H) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(A, B, C, D, E, F, G, H, I) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern fn(A, B, C, D, E, F, G, H, I) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern fn(A, B, C, D, E, F, G, H, I, J) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I, J) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
• impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
• impl<T> Ord for PhantomData<T> where
    T: ?Sized, 
• impl Ord for char
• impl Ord for usize
• impl Ord for u8
• impl Ord for u16
• impl Ord for u32
• impl Ord for u64
• impl Ord for u128
• impl Ord for isize
• impl Ord for i8
• impl Ord for i16
• impl Ord for i32
• impl Ord for i64
• impl Ord for i128
• impl Ord for TypeId
• impl<T> Ord for [T; 0] where
    T: Ord, 
• impl<T> Ord for [T; 1] where
    T: Ord, 
• impl<T> Ord for [T; 2] where
    T: Ord, 
• impl<T> Ord for [T; 3] where
    T: Ord, 
• impl<T> Ord for [T; 4] where
    T: Ord, 
• impl<T> Ord for [T; 5] where
    T: Ord, 
• impl<T> Ord for [T; 6] where
    T: Ord, 
• impl<T> Ord for [T; 7] where
    T: Ord, 
• impl<T> Ord for [T; 8] where
    T: Ord, 
• impl<T> Ord for [T; 9] where
    T: Ord, 
• impl<T> Ord for [T; 10] where
    T: Ord, 
• impl<T> Ord for [T; 11] where
    T: Ord, 
• impl<T> Ord for [T; 12] where
    T: Ord, 
• impl<T> Ord for [T; 13] where
    T: Ord, 
• impl<T> Ord for [T; 14] where
    T: Ord, 
• impl<T> Ord for [T; 15] where
    T: Ord, 
• impl<T> Ord for [T; 16] where
    T: Ord, 
• impl<T> Ord for [T; 17] where
    T: Ord, 
• impl<T> Ord for [T; 18] where
    T: Ord, 
• impl<T> Ord for [T; 19] where
    T: Ord, 
• impl<T> Ord for [T; 20] where
    T: Ord, 
• impl<T> Ord for [T; 21] where
    T: Ord, 
• impl<T> Ord for [T; 22] where
    T: Ord, 
• impl<T> Ord for [T; 23] where
    T: Ord, 
• impl<T> Ord for [T; 24] where
    T: Ord, 
• impl<T> Ord for [T; 25] where
    T: Ord, 
• impl<T> Ord for [T; 26] where
    T: Ord, 
• impl<T> Ord for [T; 27] where
    T: Ord, 
• impl<T> Ord for [T; 28] where
    T: Ord, 
• impl<T> Ord for [T; 29] where
    T: Ord, 
• impl<T> Ord for [T; 30] where
    T: Ord, 
• impl<T> Ord for [T; 31] where
    T: Ord, 
• impl<T> Ord for [T; 32] where
    T: Ord, 
• impl<T> Ord for Option<T> where
    T: Ord, 
• impl<T, E> Ord for Result<T, E> where
    E: Ord,
    T: Ord, 
• impl Ord for Error
• impl<A> Ord for (A,) where
    A: Ord, 
• impl<A, B> Ord for (A, B) where
    A: Ord,
    B: Ord, 
• impl<A, B, C> Ord for (A, B, C) where
    A: Ord,
    B: Ord,
    C: Ord, 
• impl<A, B, C, D> Ord for (A, B, C, D) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord, 
• impl<A, B, C, D, E> Ord for (A, B, C, D, E) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord, 
• impl<A, B, C, D, E, F> Ord for (A, B, C, D, E, F) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord,
    F: Ord, 
• impl<A, B, C, D, E, F, G> Ord for (A, B, C, D, E, F, G) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord,
    F: Ord,
    G: Ord, 
• impl<A, B, C, D, E, F, G, H> Ord for (A, B, C, D, E, F, G, H) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord,
    F: Ord,
    G: Ord,
    H: Ord, 
• impl<A, B, C, D, E, F, G, H, I> Ord for (A, B, C, D, E, F, G, H, I) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord,
    F: Ord,
    G: Ord,
    H: Ord,
    I: Ord, 
• impl<A, B, C, D, E, F, G, H, I, J> Ord for (A, B, C, D, E, F, G, H, I, J) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord,
    F: Ord,
    G: Ord,
    H: Ord,
    I: Ord,
    J: Ord, 
• impl<A, B, C, D, E, F, G, H, I, J, K> Ord for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord,
    F: Ord,
    G: Ord,
    H: Ord,
    I: Ord,
    J: Ord,
    K: Ord, 
• impl<A, B, C, D, E, F, G, H, I, J, K, L> Ord for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord,
    F: Ord,
    G: Ord,
    H: Ord,
    I: Ord,
    J: Ord,
    K: Ord,
    L: Ord, 
• impl Ord for CString
• impl Ord for CStr
• impl Ord for OsString
• impl Ord for OsStr
• impl Ord for ErrorKind
• impl Ord for IpAddr
• impl Ord for Ipv4Addr
• impl Ord for Ipv6Addr
• impl<'a> Ord for Prefix<'a>
• impl<'a> Ord for PrefixComponent<'a>
• impl<'a> Ord for Component<'a>
• impl<'a> Ord for Components<'a>
• impl Ord for PathBuf
• impl Ord for Path
• impl Ord for Duration
• impl Ord for Instant
• impl Ord for SystemTime