# Trait bitflags::__core::prelude::v1::Ord [−] [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 `>`.

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.

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

## Implementors

- `impl<A> Ord for LinkedList<A> where A: Ord`
- `impl<A> Ord for VecDeque<A> where A: Ord`
- `impl Ord for CString`
- `impl Ord for CStr`
- `impl Ord for OsString`
- `impl Ord for OsStr`
- `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`
- `impl<T> Ord for Vec<T> where T: Ord`
- `impl Ord for Ordering`
- `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> Ord for &'a A where A: Ord + ?Sized`
- `impl<'a, A> Ord for &'a mut A where A: Ord + ?Sized`
- `impl<T> Ord for Box<T> where T: Ord + ?Sized`
- `impl<T> Ord for PhantomData<T> where T: ?Sized`
- `impl<T> Ord for Rc<T> where T: Ord + ?Sized`
- `impl Ord for String`
- `impl<T, E> Ord for Result<T, E> where E: Ord, T: 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 unsafe 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 unsafe 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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, 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 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<T> Ord for *const T where T: ?Sized`
- `impl<T> Ord for *mut T where T: ?Sized`
- `impl<'a, B> Ord for Cow<'a, B> where B: Ord + ToOwned + ?Sized`
- `impl<T> Ord for Option<T> where T: Ord`
- `impl<T> Ord for Wrapping<T> where T: Ord`
- `impl<T> Ord for NonZero<T> where T: Zeroable + Ord`
- `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 [T] where T: Ord`
- `impl Ord for str`
- `impl Ord for Error`
- `impl<A> Ord for (A,) where A: Ord`
- `impl<A, B> Ord for (A, B) where B: Ord, A: Ord`
- `impl<A, B, C> Ord for (A, B, C) where C: Ord, A: Ord, B: Ord`
- `impl<A, B, C, D> Ord for (A, B, C, D) where D: Ord, C: Ord, A: Ord, B: Ord`
- `impl<A, B, C, D, E> Ord for (A, B, C, D, E) where A: Ord, E: Ord, D: Ord, C: Ord, B: Ord`
- `impl<A, B, C, D, E, F> Ord for (A, B, C, D, E, F) where A: Ord, C: Ord, D: Ord, B: Ord, F: Ord, E: Ord`
- `impl<A, B, C, D, E, F, G> Ord for (A, B, C, D, E, F, G) where B: Ord, A: Ord, F: Ord, D: Ord, G: Ord, E: Ord, C: Ord`
- `impl<A, B, C, D, E, F, G, H> Ord for (A, B, C, D, E, F, G, H) where G: Ord, H: Ord, D: Ord, F: Ord, C: Ord, E: Ord, A: Ord, B: Ord`
- `impl<A, B, C, D, E, F, G, H, I> Ord for (A, B, C, D, E, F, G, H, I) where G: Ord, C: Ord, B: Ord, H: Ord, A: Ord, F: Ord, I: Ord, E: Ord, D: 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 C: Ord, E: Ord, D: Ord, J: Ord, I: Ord, A: Ord, B: Ord, F: Ord, G: Ord, H: 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 D: Ord, J: Ord, C: Ord, G: Ord, F: Ord, I: Ord, E: Ord, A: Ord, B: Ord, K: Ord, H: 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 H: Ord, A: Ord, I: Ord, G: Ord, D: Ord, B: Ord, E: Ord, L: Ord, J: Ord, C: Ord, F: Ord, K: Ord`
- `impl<K, V> Ord for BTreeMap<K, V> where K: Ord, V: Ord`
- `impl<T> Ord for BTreeSet<T> where T: Ord`
- `impl<E> Ord for EnumSet<E> where E: Ord`
- `impl<T> Ord for Arc<T> where T: Ord + ?Sized`

# 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

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