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

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

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

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`

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`

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`

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

## Implementations on Foreign Types

1.27.0[src]
`impl Ord for CpuidResult`
[src]
`pub fn cmp(&self, other: &CpuidResult) -> Ordering`

## Implementors

1.34.0[src]
`impl Ord for Infallible`
[src]
`impl Ord for ErrorKind`
1.7.0[src]
`impl Ord for IpAddr`
[src]
`impl Ord for SocketAddr`
[src]
`impl Ord for Ordering`
[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 !`
[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 ()`
[src]
`impl Ord for usize`
[src]
`impl Ord for TypeId`
[src]
`impl Ord for CStr`
[src]
`impl Ord for CString`
[src]
`impl Ord for OsStr`
[src]
`impl Ord for OsString`
[src]
`impl Ord for Error`
1.33.0[src]
`impl Ord for PhantomPinned`
[src]
`impl Ord for Ipv4Addr`
[src]
`impl Ord for Ipv6Addr`
1.45.0[src]
`impl Ord for SocketAddrV4`
1.45.0[src]
`impl Ord for SocketAddrV6`
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`
[src]
`impl Ord for Components<'_>`
[src]
`impl Ord for Path`
[src]
`impl Ord for PathBuf`
[src]
`impl Ord for PrefixComponent<'_>`
[src]
`impl Ord for String`
1.3.0[src]
`impl Ord for Duration`
1.8.0[src]
`impl Ord for Instant`
1.8.0[src]
`impl Ord for SystemTime`
[src]
`impl<'_, A> Ord for &'_ A where
A: Ord + ?Sized,`
[src]
`impl<'_, A> Ord for &'_ mut A where
A: Ord + ?Sized,`
[src]
`impl<'_, B> Ord for Cow<'_, B> where
B: Ord + ToOwned + ?Sized,`
[src]
`impl<'a> Ord for Component<'a>`
[src]
`impl<'a> Ord for Prefix<'a>`
1.10.0[src]
`impl<'a> Ord for Location<'a>`
[src]
`impl<A> Ord for (A,) where
A: Ord + ?Sized,`
[src]
`impl<A, B> Ord for (A, B) where
B: Ord + ?Sized,
A: Ord,`
[src]
`impl<A, B, C> Ord for (A, B, C) where
C: Ord + ?Sized,
B: Ord,
A: Ord,`
[src]
`impl<A, B, C, D> Ord for (A, B, C, D) where
C: Ord,
B: Ord,
A: Ord,
D: Ord + ?Sized,`
[src]
`impl<A, B, C, D, E> Ord for (A, B, C, D, E) where
C: Ord,
E: Ord + ?Sized,
B: Ord,
A: Ord,
D: Ord,`
[src]
`impl<A, B, C, D, E, F> Ord for (A, B, C, D, E, F) where
C: Ord,
F: Ord + ?Sized,
E: Ord,
B: Ord,
A: Ord,
D: Ord,`
[src]
`impl<A, B, C, D, E, F, G> Ord for (A, B, C, D, E, F, G) where
C: Ord,
F: Ord,
E: Ord,
B: Ord,
A: Ord,
G: Ord + ?Sized,
D: Ord,`
[src]
`impl<A, B, C, D, E, F, G, H> Ord for (A, B, C, D, E, F, G, H) where
C: Ord,
F: Ord,
E: Ord,
H: Ord + ?Sized,
B: Ord,
A: Ord,
G: Ord,
D: Ord,`
[src]
`impl<A, B, C, D, E, F, G, H, I> Ord for (A, B, C, D, E, F, G, H, I) where
C: Ord,
F: Ord,
I: Ord + ?Sized,
E: Ord,
H: Ord,
B: Ord,
A: Ord,
G: Ord,
D: Ord,`
[src]
`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,
F: Ord,
I: Ord,
E: Ord,
H: Ord,
B: Ord,
A: Ord,
J: Ord + ?Sized,
G: Ord,
D: Ord,`
[src]
`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
C: Ord,
F: Ord,
K: Ord + ?Sized,
I: Ord,
E: Ord,
H: Ord,
B: Ord,
A: Ord,
J: Ord,
G: Ord,
D: Ord,`
[src]
`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
C: Ord,
F: Ord,
K: Ord,
I: Ord,
E: Ord,
H: Ord,
B: Ord,
A: Ord,
J: Ord,
G: Ord,
D: Ord,
L: Ord + ?Sized,`
[src]
`impl<Dyn> Ord for DynMetadata<Dyn> where
Dyn: ?Sized,`
[src]
`impl<K, V> Ord for BTreeMap<K, V> where
K: Ord,
V: Ord,`
1.41.0[src]
`impl<P> Ord for Pin<P> where
P: Deref,
<P as Deref>::Target: Ord,`
1.4.0[src]
`impl<Ret> Ord for fn() -> Ret`
1.4.0[src]
`impl<Ret> Ord for extern "C" fn() -> Ret`
1.4.0[src]
`impl<Ret> Ord for unsafe fn() -> Ret`
1.4.0[src]
`impl<Ret> Ord for unsafe extern "C" fn() -> Ret`
1.4.0[src]
`impl<Ret, A> Ord for 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 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> 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, B> Ord for 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 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> 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, C> Ord for 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 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> 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, D> Ord for 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 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> 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, E> Ord for 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 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> 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, 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 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 unsafe 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, 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 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 unsafe 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, 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 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 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> 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, 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 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 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> 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, 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 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 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> 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, 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 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 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> 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, 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 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 unsafe 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`
[src]
`impl<T> Ord for Option<T> where
T: Ord,`
1.36.0[src]
`impl<T> Ord for Poll<T> where
T: Ord,`
[src]
`impl<T> Ord for *const T where
T: ?Sized,`
[src]
`impl<T> Ord for *mut T where
T: ?Sized,`
[src]
`impl<T> Ord for [T] where
T: Ord,`
1.10.0[src]
`impl<T> Ord for Cell<T> where
T: Ord + Copy,`
1.10.0[src]
`impl<T> Ord for RefCell<T> where
T: Ord + ?Sized,`
[src]
`impl<T> Ord for BTreeSet<T> where
T: Ord,`
[src]
`impl<T> Ord for LinkedList<T> where
T: Ord,`
[src]
`impl<T> Ord for PhantomData<T> where
T: ?Sized,`
1.20.0[src]
`impl<T> Ord for ManuallyDrop<T> where
T: Ord + ?Sized,`
[src]
`impl<T> Ord for Wrapping<T> where
T: Ord,`
1.25.0[src]
`impl<T> Ord for NonNull<T> where
T: ?Sized,`
[src]
`impl<T> Ord for Rc<T> where
T: Ord + ?Sized,`
[src]
`impl<T> Ord for Arc<T> where
T: Ord + ?Sized,`
1.19.0[src]
`impl<T> Ord for Reverse<T> where
T: Ord,`
[src]
`impl<T, A> Ord for Box<T, A> where
T: Ord + ?Sized,
A: Allocator,`
[src]
`impl<T, A> Ord for VecDeque<T, A> where
T: Ord,
A: Allocator,`
[src]
`impl<T, A> Ord for Vec<T, A> where
T: Ord,
A: Allocator,`
[src]
`impl<T, E> Ord for Result<T, E> where
T: Ord,
E: Ord,`
[src]
`impl<T, const N: usize> Ord for [T; N] where
T: Ord,`
[src]
`impl<Y, R> Ord for GeneratorState<Y, R> where
R: Ord,
Y: Ord,`