# Trait std::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`:

    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
        }
    }Run

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

## 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<E> Ord for EnumSet<E> where E: 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 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 isize`
- `impl Ord for i8`
- `impl Ord for i16`
- `impl Ord for i32`
- `impl Ord for i64`
- `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`

# 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`)