Trait std_prelude::Ord

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

    fn max(self, other: Self) -> Self { ... }
    fn min(self, other: Self) -> Self { ... }
}

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 on structs, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct's members. When derived on enums, variants are ordered by their top-to-bottom declaration order.

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.

Implementations of PartialEq, PartialOrd, and Ord must agree with each other. It's easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

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

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

By convention, self.cmp(&other) returns the ordering matching the expression self <operator> other if true.

Examples

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);

Provided Methods

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

Returns the second argument if the comparison determines them to be equal.

Examples

assert_eq!(2, 1.max(2));
assert_eq!(2, 2.max(2));

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

Returns the first argument if the comparison determines them to be equal.

Examples

assert_eq!(1, 1.min(2));
assert_eq!(2, 2.min(2));

Implementations on Foreign Types

impl Ord for UnicodeVersion

fn cmp(&self, __arg_0: &UnicodeVersion) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for unsafe extern "C" fn(A, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Wrapping<T> where
    T: Ord, 

fn cmp(&self, __arg_0: &Wrapping<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 4] where
    T: Ord, 

fn cmp(&self, other: &[T; 4]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B> Ord for (A, B) where
    A: Ord,
    B: Ord + ?Sized, 

fn cmp(&self, other: &(A, B)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 22] where
    T: Ord, 

fn cmp(&self, other: &[T; 22]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u8

fn cmp(&self, other: &u8) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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

fn cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret

fn cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for TypeId

fn cmp(&self, __arg_0: &TypeId) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for extern "C" fn() -> Ret

fn cmp(&self, other: &extern "C" fn() -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 31] where
    T: Ord, 

fn cmp(&self, other: &[T; 31]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for NonZero<T> where
    T: Zeroable + Ord, 

fn cmp(&self, __arg_0: &NonZero<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C> Ord for (A, B, C) where
    A: Ord,
    B: Ord,
    C: Ord + ?Sized, 

fn cmp(&self, other: &(A, B, C)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for unsafe fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i64

fn cmp(&self, other: &i64) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a, A> Ord for &'a A where
    A: Ord + ?Sized, 

fn cmp(&self, other: &&'a A) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for *mut T where
    T: ?Sized, 

fn cmp(&self, other: &*mut T) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 0] where
    T: Ord, 

fn cmp(&self, other: &[T; 0]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for unsafe fn(A, B, C, D) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Cell<T> where
    T: Copy + Ord, 

fn cmp(&self, other: &Cell<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for ManuallyDrop<T> where
    T: Ord, 

fn cmp(&self, other: &ManuallyDrop<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 23] where
    T: Ord, 

fn cmp(&self, other: &[T; 23]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for fn() -> Ret

fn cmp(&self, other: &fn() -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T] where
    T: Ord, 

Implements comparison of vectors lexicographically.

fn cmp(&self, other: &[T]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 8] where
    T: Ord, 

fn cmp(&self, other: &[T; 8]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u32

fn cmp(&self, other: &u32) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 1] where
    T: Ord, 

fn cmp(&self, other: &[T; 1]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for extern "C" fn(A, B, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i32

fn cmp(&self, other: &i32) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for isize

fn cmp(&self, other: &isize) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i128

fn cmp(&self, other: &i128) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for extern "C" fn(A, B) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 27] where
    T: Ord, 

fn cmp(&self, other: &[T; 27]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 30] where
    T: Ord, 

fn cmp(&self, other: &[T; 30]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 25] where
    T: Ord, 

fn cmp(&self, other: &[T; 25]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 12] where
    T: Ord, 

fn cmp(&self, other: &[T; 12]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 6] where
    T: Ord, 

fn cmp(&self, other: &[T; 6]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 11] where
    T: Ord, 

fn cmp(&self, other: &[T; 11]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for unsafe fn(A) -> Ret

fn cmp(&self, other: &unsafe fn(A) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 13] where
    T: Ord, 

fn cmp(&self, other: &[T; 13]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 28] where
    T: Ord, 

fn cmp(&self, other: &[T; 28]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i8

fn cmp(&self, other: &i8) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 7] where
    T: Ord, 

fn cmp(&self, other: &[T; 7]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for RefCell<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &RefCell<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 24] where
    T: Ord, 

fn cmp(&self, other: &[T; 24]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 10] where
    T: Ord, 

fn cmp(&self, other: &[T; 10]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 9] where
    T: Ord, 

fn cmp(&self, other: &[T; 9]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 14] where
    T: Ord, 

fn cmp(&self, other: &[T; 14]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T, E> Ord for Result<T, E> where
    E: Ord,
    T: Ord, 

fn cmp(&self, __arg_0: &Result<T, E>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 17] where
    T: Ord, 

fn cmp(&self, other: &[T; 17]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 20] where
    T: Ord, 

fn cmp(&self, other: &[T; 20]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E> Ord for (A, B, C, D, E) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 2] where
    T: Ord, 

fn cmp(&self, other: &[T; 2]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A> Ord for (A,) where
    A: Ord + ?Sized, 

fn cmp(&self, other: &(A,)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for extern "C" fn(A) -> Ret

fn cmp(&self, other: &extern "C" fn(A) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for fn(A, B) -> Ret

fn cmp(&self, other: &fn(A, B) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a, A> Ord for &'a mut A where
    A: Ord + ?Sized, 

fn cmp(&self, other: &&'a mut A) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for fn(A, B, C, D) -> Ret

fn cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 19] where
    T: Ord, 

fn cmp(&self, other: &[T; 19]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 32] where
    T: Ord, 

fn cmp(&self, other: &[T; 32]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for fn(A, B, C) -> Ret

fn cmp(&self, other: &fn(A, B, C) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for char

fn cmp(&self, other: &char) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for unsafe fn() -> Ret

fn cmp(&self, other: &unsafe fn() -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 26] where
    T: Ord, 

fn cmp(&self, other: &[T; 26]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for PhantomData<T> where
    T: ?Sized, 

fn cmp(&self, _other: &PhantomData<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for usize

fn cmp(&self, other: &usize) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for str

Implements ordering of strings.

Strings are ordered lexicographically by their byte values. This orders Unicode code points based on their positions in the code charts. This is not necessarily the same as "alphabetical" order, which varies by language and locale. Sorting strings according to culturally-accepted standards requires locale-specific data that is outside the scope of the str type.

fn cmp(&self, other: &str) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for bool

fn cmp(&self, other: &bool) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u16

fn cmp(&self, other: &u16) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 16] where
    T: Ord, 

fn cmp(&self, other: &[T; 16]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 5] where
    T: Ord, 

fn cmp(&self, other: &[T; 5]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for fn(A) -> Ret

fn cmp(&self, other: &fn(A) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u64

fn cmp(&self, other: &u64) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D> Ord for (A, B, C, D) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord + ?Sized, 

fn cmp(&self, other: &(A, B, C, D)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Reverse<T> where
    T: Ord, 

fn cmp(&self, other: &Reverse<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 29] where
    T: Ord, 

fn cmp(&self, other: &[T; 29]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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

fn cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 15] where
    T: Ord, 

fn cmp(&self, other: &[T; 15]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 3] where
    T: Ord, 

fn cmp(&self, other: &[T; 3]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Error

fn cmp(&self, __arg_0: &Error) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 21] where
    T: Ord, 

fn cmp(&self, other: &[T; 21]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Option<T> where
    T: Ord, 

fn cmp(&self, __arg_0: &Option<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for unsafe extern "C" fn() -> Ret

fn cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i16

fn cmp(&self, other: &i16) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for ()

fn cmp(&self, _other: &()) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for *const T where
    T: ?Sized, 

fn cmp(&self, other: &*const T) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

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

fn cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Y, R> Ord for GeneratorState<Y, R> where
    R: Ord,
    Y: Ord, 

fn cmp(&self, __arg_0: &GeneratorState<Y, R>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for unsafe extern "C" fn(A) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 18] where
    T: Ord, 

fn cmp(&self, other: &[T; 18]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for unsafe fn(A, B, C) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for extern "C" fn(A, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u128

fn cmp(&self, other: &u128) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Box<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &Box<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for BTreeSet<T> where
    T: Ord, 

fn cmp(&self, __arg_0: &BTreeSet<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a, B> Ord for Cow<'a, B> where
    B: Ord + ToOwned + ?Sized, 

fn cmp(&self, other: &Cow<'a, B>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for String

fn cmp(&self, __arg_0: &String) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Vec<T> where
    T: Ord, 

Implements ordering of vectors, lexicographically.

fn cmp(&self, other: &Vec<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for LinkedList<T> where
    T: Ord, 

fn cmp(&self, other: &LinkedList<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A> Ord for VecDeque<A> where
    A: Ord, 

fn cmp(&self, other: &VecDeque<A>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for Components<'a>

fn cmp(&self, other: &Components<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for Prefix<'a>

fn cmp(&self, __arg_0: &Prefix<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for OsStr

fn cmp(&self, other: &OsStr) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for CString

fn cmp(&self, __arg_0: &CString) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for ErrorKind

fn cmp(&self, __arg_0: &ErrorKind) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Instant

fn cmp(&self, __arg_0: &Instant) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for CStr

fn cmp(&self, other: &CStr) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for Component<'a>

fn cmp(&self, __arg_0: &Component<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for PrefixComponent<'a>

fn cmp(&self, other: &PrefixComponent<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for SystemTime

fn cmp(&self, __arg_0: &SystemTime) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for IpAddr

fn cmp(&self, __arg_0: &IpAddr) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Ipv6Addr

fn cmp(&self, other: &Ipv6Addr) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Ipv4Addr

fn cmp(&self, other: &Ipv4Addr) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

Implementors

• impl Ord for Ordering
• impl Ord for !
• impl<T> Ord for Arc<T> where
    T: Ord + ?Sized, 
• impl<T> Ord for Rc<T> where
    T: Ord + ?Sized, 
• impl<K, V> Ord for BTreeMap<K, V> where
    K: Ord,
    V: Ord, 
• impl Ord for Duration
• impl Ord for Path
• impl Ord for OsString
• impl Ord for PathBuf