Trait sp_std::cmp::Ord

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

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

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 asymmetric: 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 derived on structs, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct's members. When derived on enums, variants are ordered by their top-to-bottom declaration order.

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.

Implementations of PartialEq, PartialOrd, and Ord must agree with each other. That is, a.cmp(b) == Ordering::Equal if and only if a == b and Some(a.cmp(b)) == a.partial_cmp(b) for all a and b. It's easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

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

Required methods

#[must_use]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);

Loading content...

Provided methods

#[must_use]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));

#[must_use]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));

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

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

#![feature(clamp)]

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

Loading content...

Implementations on Foreign Types

impl Ord for CString

fn cmp(&self, other: &CString) -> Ordering

impl Ord for ErrorKind

fn cmp(&self, other: &ErrorKind) -> Ordering

impl<'a> Ord for Prefix<'a>

fn cmp(&self, other: &Prefix<'a>) -> Ordering

impl<'_> Ord for PrefixComponent<'_>

fn cmp(&self, other: &PrefixComponent<'_>) -> Ordering

impl Ord for PathBuf

fn cmp(&self, other: &PathBuf) -> Ordering

impl Ord for Ipv4Addr

fn cmp(&self, other: &Ipv4Addr) -> Ordering

impl Ord for SystemTime

fn cmp(&self, other: &SystemTime) -> Ordering

impl Ord for OsStr

fn cmp(&self, other: &OsStr) -> Ordering

impl Ord for IpAddr

fn cmp(&self, other: &IpAddr) -> Ordering

impl Ord for OsString

fn cmp(&self, other: &OsString) -> Ordering

impl<'_> Ord for Components<'_>

fn cmp(&self, other: &Components<'_>) -> Ordering

impl Ord for Instant

fn cmp(&self, other: &Instant) -> Ordering

impl<'a> Ord for Component<'a>

fn cmp(&self, other: &Component<'a>) -> Ordering

impl Ord for Ipv6Addr

fn cmp(&self, other: &Ipv6Addr) -> Ordering

impl Ord for CStr

fn cmp(&self, other: &CStr) -> Ordering

impl Ord for Path

fn cmp(&self, other: &Path) -> Ordering

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> Ordering

impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering

impl<Ret, A, B, C, D, E> Ord for fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Ordering

impl Ord for i64

fn cmp(&self, other: &i64) -> Ordering

impl<Ret> Ord for unsafe fn() -> Ret

fn cmp(&self, other: &unsafe fn() -> Ret) -> Ordering

impl<'_, A> Ord for &'_ mut A where
    A: Ord + ?Sized, 

fn cmp(&self, other: &&'_ mut A) -> Ordering

impl<T> Ord for *const T where
    T: ?Sized, 

fn cmp(&self, other: &*const T) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering

impl Ord for u32

fn cmp(&self, other: &u32) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering

impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> Ordering

impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering

impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> Ordering

impl<Ret> Ord for extern "C" fn() -> Ret

fn cmp(&self, other: &extern "C" fn() -> Ret) -> Ordering

impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> Ordering

impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Ordering

impl<Ret, A> Ord for fn(A) -> Ret

fn cmp(&self, other: &fn(A) -> Ret) -> Ordering

impl<Ret, A> Ord for unsafe fn(A) -> Ret

fn cmp(&self, other: &unsafe fn(A) -> Ret) -> Ordering

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

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> Ordering

impl Ord for !

fn cmp(&self, &!) -> Ordering

impl<Ret, A, B, C, D, E> Ord for unsafe fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> Ordering

impl<Ret> Ord for fn() -> Ret

fn cmp(&self, other: &fn() -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering

impl Ord for u64

fn cmp(&self, other: &u64) -> Ordering

impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> Ordering

impl<Ret, A, B, C> Ord for fn(A, B, C) -> Ret

fn cmp(&self, other: &fn(A, B, C) -> Ret) -> Ordering

impl Ord for bool

fn cmp(&self, other: &bool) -> Ordering

impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

impl Ord for i16

fn cmp(&self, other: &i16) -> Ordering

impl<A> Ord for (A,) where
    A: Ord + ?Sized, 

fn cmp(&self, other: &(A,)) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering

impl<A, B, C, D, E> Ord for (A, B, C, D, E) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord,
    E: Ord + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E)) -> Ordering

impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering

impl<A, B, C, D> Ord for (A, B, C, D) where
    A: Ord,
    B: Ord,
    C: Ord,
    D: Ord + ?Sized, 

fn cmp(&self, other: &(A, B, C, D)) -> Ordering

impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering

impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret

fn cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Ordering

impl<const N: usize, T> Ord for [T; N] where
    T: Ord,
    [T; N]: LengthAtMost32, 

Implements comparison of arrays lexicographically.

fn cmp(&self, other: &[T; N]) -> Ordering

impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering

impl<A, B> Ord for (A, B) where
    A: Ord,
    B: Ord + ?Sized, 

fn cmp(&self, other: &(A, B)) -> Ordering

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F)) -> Ordering

impl<Ret> Ord for unsafe extern "C" fn() -> Ret

fn cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Ordering

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

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> Ordering

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> Ordering

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G)) -> Ordering

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Ordering

impl<Ret, A, B> Ord for extern "C" fn(A, B) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Ordering

impl<Ret, A> Ord for extern "C" fn(A, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Ordering

impl<Ret, A, B, C, D, E, F, G, H> Ord for fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

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

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering

impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Ordering

impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

impl<Ret, A> Ord for unsafe extern "C" fn(A) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A) -> Ret) -> Ordering

impl<T> Ord for *mut T where
    T: ?Sized, 

fn cmp(&self, other: &*mut T) -> Ordering

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

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering

impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> Ordering

impl Ord for char

fn cmp(&self, other: &char) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Ordering

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering

impl<Ret, A, B, C, D> Ord for unsafe fn(A, B, C, D) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Ordering

impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> Ordering

impl Ord for NoneError

fn cmp(&self, other: &NoneError) -> Ordering

impl<A, B, C> Ord for (A, B, C) where
    A: Ord,
    B: Ord,
    C: Ord + ?Sized, 

fn cmp(&self, other: &(A, B, C)) -> Ordering

impl Ord for i32

fn cmp(&self, other: &i32) -> Ordering

impl<T> Ord for [T] where
    T: Ord, 

Implements comparison of vectors lexicographically.

fn cmp(&self, other: &[T]) -> Ordering

impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Ordering

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering

impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Ordering

impl Ord for i128

fn cmp(&self, other: &i128) -> Ordering

impl<T> Ord for Poll<T> where
    T: Ord, 

fn cmp(&self, other: &Poll<T>) -> Ordering

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 + ?Sized, 

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Ordering

impl Ord for i8

fn cmp(&self, other: &i8) -> Ordering

impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering

impl Ord for str

Implements ordering of strings.

Strings are ordered lexicographically by their byte values. This orders Unicode code points based on their positions in the code charts. This is not necessarily the same as "alphabetical" order, which varies by language and locale. Sorting strings according to culturally-accepted standards requires locale-specific data that is outside the scope of the str type.

fn cmp(&self, other: &str) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering

impl<Ret, A, B, C, D> Ord for fn(A, B, C, D) -> Ret

fn cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Ordering

impl<T> Ord for Option<T> where
    T: Ord, 

fn cmp(&self, other: &Option<T>) -> Ordering

impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Ordering

impl<P> Ord for Pin<P> where
    P: Deref,
    <P as Deref>::Target: Ord, 

fn cmp(&self, other: &Pin<P>) -> Ordering

impl<'_, A> Ord for &'_ A where
    A: Ord + ?Sized, 

fn cmp(&self, other: &&'_ A) -> Ordering

impl Ord for isize

fn cmp(&self, other: &isize) -> Ordering

impl Ord for ()

fn cmp(&self, _other: &()) -> Ordering

impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

impl Ord for u128

fn cmp(&self, other: &u128) -> Ordering

impl Ord for u16

fn cmp(&self, other: &u16) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering

impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> Ordering

impl<Ret, A, B, C> Ord for unsafe fn(A, B, C) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Ordering

impl<Ret, A> Ord for unsafe extern "C" fn(A, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> Ordering

impl<Ret, A, B> Ord for fn(A, B) -> Ret

fn cmp(&self, other: &fn(A, B) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering

impl Ord for CpuidResult

fn cmp(&self, other: &CpuidResult) -> Ordering

impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering

impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering

impl<Ret, A> Ord for extern "C" fn(A) -> Ret

fn cmp(&self, other: &extern "C" fn(A) -> Ret) -> Ordering

impl<Ret, A, B> Ord for extern "C" fn(A, B, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> Ordering

impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering

impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> Ordering

impl Ord for Duration

fn cmp(&self, other: &Duration) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering

impl Ord for u8

fn cmp(&self, other: &u8) -> Ordering

impl Ord for usize

fn cmp(&self, other: &usize) -> Ordering

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

fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering

impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> Ordering

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

fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering

impl Ord for String

fn cmp(&self, other: &String) -> Ordering

impl<T> Ord for LinkedList<T> where
    T: Ord, 

fn cmp(&self, other: &LinkedList<T>) -> Ordering

impl<T> Ord for Arc<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &Arc<T>) -> Ordering

Comparison for two Arcs.

The two are compared by calling cmp() on their inner values.

Examples

use std::sync::Arc;
use std::cmp::Ordering;

let five = Arc::new(5);

assert_eq!(Ordering::Less, five.cmp(&Arc::new(6)));

Loading content...

Implementors

impl Ord for Ordering

fn cmp(&self, other: &Ordering) -> Ordering

impl Ord for Infallible

fn cmp(&self, _other: &Infallible) -> Ordering

impl Ord for TypeId

fn cmp(&self, other: &TypeId) -> Ordering

impl Ord for Error

fn cmp(&self, other: &Error) -> Ordering

impl Ord for PhantomPinned

fn cmp(&self, other: &PhantomPinned) -> Ordering

impl Ord for NonZeroI128

fn cmp(&self, other: &NonZeroI128) -> Ordering

impl Ord for NonZeroI16

fn cmp(&self, other: &NonZeroI16) -> Ordering

impl Ord for NonZeroI32

fn cmp(&self, other: &NonZeroI32) -> Ordering

impl Ord for NonZeroI64

fn cmp(&self, other: &NonZeroI64) -> Ordering

impl Ord for NonZeroI8

fn cmp(&self, other: &NonZeroI8) -> Ordering

impl Ord for NonZeroIsize

fn cmp(&self, other: &NonZeroIsize) -> Ordering

impl Ord for NonZeroU128

fn cmp(&self, other: &NonZeroU128) -> Ordering

impl Ord for NonZeroU16

fn cmp(&self, other: &NonZeroU16) -> Ordering

impl Ord for NonZeroU32

fn cmp(&self, other: &NonZeroU32) -> Ordering

impl Ord for NonZeroU64

fn cmp(&self, other: &NonZeroU64) -> Ordering

impl Ord for NonZeroU8

fn cmp(&self, other: &NonZeroU8) -> Ordering

impl Ord for NonZeroUsize

fn cmp(&self, other: &NonZeroUsize) -> Ordering

impl<'_, B> Ord for Cow<'_, B> where
    B: Ord + ToOwned + ?Sized, 

fn cmp(&self, other: &Cow<'_, B>) -> Ordering

impl<A> Ord for VecDeque<A> where
    A: Ord, 

fn cmp(&self, other: &VecDeque<A>) -> Ordering

impl<K, V> Ord for BTreeMap<K, V> where
    K: Ord,
    V: Ord, 

fn cmp(&self, other: &BTreeMap<K, V>) -> Ordering

impl<T> Ord for Cell<T> where
    T: Ord + Copy, 

fn cmp(&self, other: &Cell<T>) -> Ordering

impl<T> Ord for RefCell<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &RefCell<T>) -> Ordering

Panics

Panics if the value in either RefCell is currently borrowed.

impl<T> Ord for BTreeSet<T> where
    T: Ord, 

fn cmp(&self, other: &BTreeSet<T>) -> Ordering

impl<T> Ord for PhantomData<T> where
    T: ?Sized, 

fn cmp(&self, _other: &PhantomData<T>) -> Ordering

impl<T> Ord for ManuallyDrop<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &ManuallyDrop<T>) -> Ordering

impl<T> Ord for Wrapping<T> where
    T: Ord, 

fn cmp(&self, other: &Wrapping<T>) -> Ordering

impl<T> Ord for Box<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &Box<T>) -> Ordering

impl<T> Ord for Reverse<T> where
    T: Ord, 

fn cmp(&self, other: &Reverse<T>) -> Ordering

impl<T> Ord for Vec<T> where
    T: Ord, 

Implements ordering of vectors, lexicographically.

fn cmp(&self, other: &Vec<T>) -> Ordering

impl<T> Ord for NonNull<T> where
    T: ?Sized, 

fn cmp(&self, other: &NonNull<T>) -> Ordering

impl<T> Ord for Rc<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &Rc<T>) -> Ordering

Comparison for two Rcs.

The two are compared by calling cmp() on their inner values.

Examples

use std::rc::Rc;
use std::cmp::Ordering;

let five = Rc::new(5);

assert_eq!(Ordering::Less, five.cmp(&Rc::new(6)));

impl<T, E> Ord for Result<T, E> where
    E: Ord,
    T: Ord, 

fn cmp(&self, other: &Result<T, E>) -> Ordering

impl<Y, R> Ord for GeneratorState<Y, R> where
    R: Ord,
    Y: Ord, 

fn cmp(&self, other: &GeneratorState<Y, R>) -> Ordering

Loading content...