Trait core::cmp::Ord

#[lang = "ord"]
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,
    { ... }
}

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 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. 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: &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
    }
}

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

Loading content...

Provided methods

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

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

Loading content...

Implementors

impl Ord for !

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for ()

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for Ordering

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for TypeId

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for CpuidResult

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for UnicodeVersion

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for Error

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for PhantomPinned

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for NonZeroU128

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for NonZeroU16

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for NonZeroU32

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for NonZeroU64

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for NonZeroU8

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for NonZeroUsize

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for NoneError

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for Duration

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for bool

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for char

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for i8

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for i16

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for i32

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for i64

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for i128

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for isize

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for u8

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for u16

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for u32

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for u64

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for u128

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl Ord for usize

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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,

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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,

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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,

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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,

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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,

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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,

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<P: Ord> Ord for Pin<P>

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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: &Self) -> Ordering

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 0]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 1]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 2]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 3]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 4]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 5]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 6]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 7]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 8]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 9]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 10]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 11]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 12]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 13]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 14]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 15]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 16]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 17]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 18]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 19]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 20]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 21]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 22]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 23]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 24]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 25]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 26]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 27]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 28]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 29]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 30]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 31]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T; 32]

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

impl<T: Ord> Ord for [T]

Implements comparison of vectors lexicographically.

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

Panics

Panics if the value in either RefCell is currently borrowed.

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

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

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

fn max(self, other: Self) -> Self where     Self: Sized,

fn min(self, other: Self) -> Self where     Self: Sized,

Loading content...