# Trait core::cmp::Ord 1.0.0 [−] [src]

    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 `derive`d, 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`:

fn main() { 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 } } }

    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

fn main() { 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); }

    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<T: Ord> Ord for Wrapping<T>`
- `impl<T: Ord + Zeroable> Ord for NonZero<T>`
- `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: ?Sized> Ord for *const T`
- `impl<T: ?Sized> Ord for *mut T`
- `impl<T: ?Sized> Ord for PhantomData<T>`
- `impl Ord for ()`
- `impl Ord for bool`
- `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 isize`
- `impl Ord for i8`
- `impl Ord for i16`
- `impl Ord for i32`
- `impl Ord for i64`
- `impl<'a, A: ?Sized> Ord for &'a A where A: Ord`
- `impl<'a, A: ?Sized> Ord for &'a mut A where A: Ord`
- `impl Ord for Ordering`
- `impl<T: Ord> Ord for [T; 0]`
- `impl<T: Ord> Ord for [T; 1]`
- `impl<T: Ord> Ord for [T; 2]`
- `impl<T: Ord> Ord for [T; 3]`
- `impl<T: Ord> Ord for [T; 4]`
- `impl<T: Ord> Ord for [T; 5]`
- `impl<T: Ord> Ord for [T; 6]`
- `impl<T: Ord> Ord for [T; 7]`
- `impl<T: Ord> Ord for [T; 8]`
- `impl<T: Ord> Ord for [T; 9]`
- `impl<T: Ord> Ord for [T; 10]`
- `impl<T: Ord> Ord for [T; 11]`
- `impl<T: Ord> Ord for [T; 12]`
- `impl<T: Ord> Ord for [T; 13]`
- `impl<T: Ord> Ord for [T; 14]`
- `impl<T: Ord> Ord for [T; 15]`
- `impl<T: Ord> Ord for [T; 16]`
- `impl<T: Ord> Ord for [T; 17]`
- `impl<T: Ord> Ord for [T; 18]`
- `impl<T: Ord> Ord for [T; 19]`
- `impl<T: Ord> Ord for [T; 20]`
- `impl<T: Ord> Ord for [T; 21]`
- `impl<T: Ord> Ord for [T; 22]`
- `impl<T: Ord> Ord for [T; 23]`
- `impl<T: Ord> Ord for [T; 24]`
- `impl<T: Ord> Ord for [T; 25]`
- `impl<T: Ord> Ord for [T; 26]`
- `impl<T: Ord> Ord for [T; 27]`
- `impl<T: Ord> Ord for [T; 28]`
- `impl<T: Ord> Ord for [T; 29]`
- `impl<T: Ord> Ord for [T; 30]`
- `impl<T: Ord> Ord for [T; 31]`
- `impl<T: Ord> Ord for [T; 32]`
- `impl<T: Ord + Copy> Ord for Cell<T>`
- `impl<T: ?Sized + Ord> Ord for RefCell<T>`
- `impl<T: Ord> Ord for Option<T>`
- `impl<T: Ord, E: Ord> Ord for Result<T, E>`
- `impl<T: Ord> Ord for [T]`
- `impl Ord for str`
- `impl Ord for Error`
- `impl<A: Ord> Ord for (A,)`
- `impl<A: Ord, B: Ord> Ord for (A, B)`
- `impl<A: Ord, B: Ord, C: Ord> Ord for (A, B, C)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord> Ord for (A, B, C, D)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord> Ord for (A, B, C, D, E)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord> Ord for (A, B, C, D, E, F)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord> Ord for (A, B, C, D, E, F, G)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord> Ord for (A, B, C, D, E, F, G, H)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord> Ord for (A, B, C, D, E, F, G, H, I)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord> Ord for (A, B, C, D, E, F, G, H, I, J)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K)`
- `impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K, L)`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)