Trait std::cmp::Ord1.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`