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

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

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

Expand description

Trait for types that form a total order.

Implementations must be consistent with the `PartialOrd` implementation, and ensure `max`, `min`, and `clamp` are consistent with `cmp`:

- `partial_cmp(a, b) == Some(cmp(a, b))`.
- `max(a, b) == max_by(a, b, cmp)` (ensured by the default implementation).
- `min(a, b) == min_by(a, b, cmp)` (ensured by the default implementation).
- For `a.clamp(min, max)`, see the method docs (ensured by the default implementation).

It’s easy to accidentally make `cmp` and `partial_cmp` disagree by deriving some of the traits and manually implementing others.

## Corollaries

From the above and the requirements of `PartialOrd`, it follows that `<` defines a strict total order. This means that for all `a`, `b` and `c`:

- exactly one of `a < b`, `a == b` or `a > b` is true; and
- `<` is 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 on structs, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct’s members. When `derive`d on enums, variants are ordered by their top-to-bottom discriminant order.

## Lexicographical comparison

Lexicographical comparison is an operation with the following properties:

- Two sequences are compared element by element.
- The first mismatching element defines which sequence is lexicographically less or greater than the other.
- If one sequence is a prefix of another, the shorter sequence is lexicographically less than the other.
- If two sequence have equivalent elements and are of the same length, then the sequences are lexicographically equal.
- An empty sequence is lexicographically less than any non-empty sequence.
- Two empty sequences are lexicographically equal.

## 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: &Self) -> Ordering {
            self.height.cmp(&other.height)
        }
    }

    impl PartialOrd for Person {
        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
            Some(self.cmp(other))
        }
    }

    impl PartialEq for Person {
        fn eq(&self, other: &Self) -> bool {
            self.height == other.height
        }
    }

Run

## Required methods

[src]
`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

## Provided methods

1.21.0[src]
`fn max(self, other: Self) -> Self where
Self: Sized,`

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

Run
1.21.0[src]
`fn min(self, other: Self) -> Self where
Self: Sized,`

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

Run
1.50.0[src]
`fn clamp(self, min: Self, max: Self) -> Self where
Self: Sized,`

Restrict a value to a certain interval.

Returns `max` if `self` is greater than `max`, and `min` if `self` is less than `min`. Otherwise this returns `self`.

# Panics

Panics if `min > max`.

# Examples

    assert!((-3).clamp(-2, 1) == -2);
    assert!(0.clamp(-2, 1) == 0);
    assert!(2.clamp(-2, 1) == 1);

Run

## Implementors

[src]
`impl Ord for !`
[src]
`impl Ord for ()`
1.34.0[src]
`impl Ord for Infallible`
[src]
`impl Ord for Ordering`
[src]
`impl Ord for TypeId`
1.27.0[src]
`impl Ord for CpuidResult`
This is supported on x86 or x86-64 only.
[src]
`impl Ord for Error`
1.33.0[src]
`impl Ord for PhantomPinned`
1.34.0[src]
`impl Ord for NonZeroI8`
1.34.0[src]
`impl Ord for NonZeroI16`
1.34.0[src]
`impl Ord for NonZeroI32`
1.34.0[src]
`impl Ord for NonZeroI64`
1.34.0[src]
`impl Ord for NonZeroI128`
1.34.0[src]
`impl Ord for NonZeroIsize`
1.28.0[src]
`impl Ord for NonZeroU8`
1.28.0[src]
`impl Ord for NonZeroU16`
1.28.0[src]
`impl Ord for NonZeroU32`
1.28.0[src]
`impl Ord for NonZeroU64`
1.28.0[src]
`impl Ord for NonZeroU128`
1.28.0[src]
`impl Ord for NonZeroUsize`
1.3.0[src]
`impl Ord for Duration`
[src]
`impl Ord for bool`
[src]
`impl Ord for char`
[src]
`impl Ord for i8`
[src]
`impl Ord for i16`
[src]
`impl Ord for i32`
[src]
`impl Ord for i64`
[src]
`impl Ord for i128`
[src]
`impl Ord for isize`
[src]
`impl Ord for str`
[src]
`impl Ord for u8`
[src]
`impl Ord for u16`
[src]
`impl Ord for u32`
[src]
`impl Ord for u64`
[src]
`impl Ord for u128`
[src]
`impl Ord for usize`
1.10.0[src]
`impl<'a> Ord for Location<'a>`
[src]
`impl<A> Ord for (A,) where
A: Ord + ?Sized,`
[src]
`impl<A: Ord, B> Ord for (A, B) where
B: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C> Ord for (A, B, C) where
C: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D> Ord for (A, B, C, D) where
D: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D: Ord, E> Ord for (A, B, C, D, E) where
E: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F> Ord for (A, B, C, D, E, F) where
F: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G> Ord for (A, B, C, D, E, F, G) where
G: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H> Ord for (A, B, C, D, E, F, G, H) where
H: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I> Ord for (A, B, C, D, E, F, G, H, I) where
I: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J> Ord for (A, B, C, D, E, F, G, H, I, J) where
J: Ord + ?Sized,`
[src]
`impl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K> Ord for (A, B, C, D, E, F, G, H, I, J, K) where
K: Ord + ?Sized,`
[src]
`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 for (A, B, C, D, E, F, G, H, I, J, K, L) where
L: Ord + ?Sized,`
[src]
`impl<A: ?Sized> Ord for &A where
A: Ord,`
[src]
`impl<A: ?Sized> Ord for &mut A where
A: Ord,`
[src]
`impl<Dyn: ?Sized> Ord for DynMetadata<Dyn>`
1.41.0[src]
`impl<P: Deref<Target: Ord>> Ord for Pin<P>`
1.4.0[src]
`impl<Ret> Ord for extern "C" fn() -> Ret`
1.4.0[src]
`impl<Ret> Ord for fn() -> Ret`
1.4.0[src]
`impl<Ret> Ord for unsafe extern "C" fn() -> Ret`
1.4.0[src]
`impl<Ret> Ord for unsafe fn() -> Ret`
1.4.0[src]
`impl<Ret, A> Ord for extern "C" fn(_: A) -> Ret`
1.4.0[src]
`impl<Ret, A> Ord for extern "C" fn(_: A, ...) -> Ret`
1.4.0[src]
`impl<Ret, A> Ord for fn(_: A) -> Ret`
1.4.0[src]
`impl<Ret, A> Ord for unsafe extern "C" fn(_: A) -> Ret`
1.4.0[src]
`impl<Ret, A> Ord for unsafe extern "C" fn(_: A, ...) -> Ret`
1.4.0[src]
`impl<Ret, A> Ord for unsafe fn(_: A) -> Ret`
1.4.0[src]
`impl<Ret, A, B> Ord for extern "C" fn(_: A, _: B) -> Ret`
1.4.0[src]
`impl<Ret, A, B> Ord for extern "C" fn(_: A, _: B, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B> Ord for fn(_: A, _: B) -> Ret`
1.4.0[src]
`impl<Ret, A, B> Ord for unsafe extern "C" fn(_: A, _: B) -> Ret`
1.4.0[src]
`impl<Ret, A, B> Ord for unsafe extern "C" fn(_: A, _: B, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B> Ord for unsafe fn(_: A, _: B) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> Ord for extern "C" fn(_: A, _: B, _: C) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> Ord for extern "C" fn(_: A, _: B, _: C, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> Ord for fn(_: A, _: B, _: C) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> Ord for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> Ord for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> Ord for unsafe fn(_: A, _: B, _: C) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D> Ord for extern "C" fn(_: A, _: B, _: C, _: D) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D> Ord for extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D> Ord for fn(_: A, _: B, _: C, _: D) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D> Ord for unsafe fn(_: A, _: B, _: C, _: D) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E> Ord for fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E> Ord for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F> Ord for fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G> Ord for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G> Ord for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G, H> Ord for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.4.0[src]
`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`
1.10.0[src]
`impl<T: Ord + Copy> Ord for Cell<T>`
1.20.0[src]
`impl<T: Ord + ?Sized> Ord for ManuallyDrop<T>`
[src]
`impl<T: Ord> Ord for Option<T>`
1.36.0[src]
`impl<T: Ord> Ord for Poll<T>`
[src]
`impl<T: Ord> Ord for Wrapping<T>`
1.19.0[src]
`impl<T: Ord> Ord for Reverse<T>`
[src]
`impl<T: Ord> Ord for [T]`
[src]
`impl<T: Ord, E: Ord> Ord for Result<T, E>`
[src]
`impl<T: Ord, const N: usize> Ord for [T; N]`
1.10.0[src]
`impl<T: ?Sized + Ord> Ord for RefCell<T>`
[src]
`impl<T: ?Sized> Ord for *const T`
[src]
`impl<T: ?Sized> Ord for *mut T`
[src]
`impl<T: ?Sized> Ord for PhantomData<T>`
1.25.0[src]
`impl<T: ?Sized> Ord for NonNull<T>`
[src]
`impl<Y: Ord, R: Ord> Ord for GeneratorState<Y, R>`