Trait sp_std::cmp::Ord

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

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

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

Provided methods

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

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

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

Implementations on Foreign Types

impl Ord for Ipv6Addr

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

impl Ord for Instant

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

impl Ord for OsString

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

impl Ord for CStr

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

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

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

impl Ord for SocketAddrV6

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

impl Ord for ErrorKind

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

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

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

impl Ord for SocketAddrV4

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

impl Ord for OsStr

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

impl Ord for SystemTime

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

impl Ord for IpAddr

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

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

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

impl Ord for SocketAddr

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

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

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

impl Ord for PathBuf

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

impl Ord for Path

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

impl Ord for Ipv4Addr

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

impl Ord for CString

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

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

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

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

pub fn cmp(&self, other: &unsafe fn() -> Ret) -> 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
    C: Ord,
    A: Ord,
    E: Ord,
    K: Ord + ?Sized,
    F: Ord,
    I: Ord,
    B: Ord,
    H: Ord,
    D: Ord,
    G: Ord,
    J: Ord, 

pub fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> 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

pub fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> 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

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

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

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

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

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

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

pub fn cmp(&self, other: &fn(A, B, C, D) -> 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

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

impl Ord for CpuidResult

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

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

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

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

pub fn cmp(&self, other: &(A, B, C, D, E, F)) -> 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

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

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

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

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

pub fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> 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

pub 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> Ord for unsafe fn(A, B, C, D, E) -> Ret

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

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

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

impl Ord for char

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

impl Ord for i8

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

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

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

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

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

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

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

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

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

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

pub fn cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> 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

pub 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 u8

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

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

pub fn cmp(&self, other: &unsafe fn(A, B, C, D) -> 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

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

impl Ord for u128

pub fn cmp(&self, other: &u128) -> 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

pub fn cmp(
    &self,
    other: &unsafe 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, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

pub 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> Ord for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

pub fn cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, ...) -> 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

pub fn cmp(
    &self,
    other: &extern "C" 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

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

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

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

impl Ord for u32

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Ord for isize

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

impl Ord for u16

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

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

Implements comparison of vectors lexicographically.

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

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

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

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

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

impl Ord for i128

pub fn cmp(&self, other: &i128) -> 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

pub fn cmp(
    &self,
    other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> 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
    C: Ord,
    A: Ord,
    E: Ord,
    K: Ord,
    F: Ord,
    I: Ord,
    B: Ord,
    H: Ord,
    D: Ord,
    G: Ord,
    J: Ord,
    L: Ord + ?Sized, 

pub 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, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

pub 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, H, I, J, K, L> Ord for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

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

impl Ord for ()

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

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

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

impl<'a> Ord for Location<'a>

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

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

pub fn cmp(&self, other: &extern "C" fn(A, B, C, D) -> 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

pub fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> 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

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

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

Implements comparison of arrays lexicographically.

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

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

pub 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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Ord for i64

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

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

pub 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, H, I, J, K> Ord for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

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

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

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

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

pub fn cmp(&self, other: &fn() -> 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

pub 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> Ord for unsafe extern "C" fn(A, B, C, ...) -> Ret

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

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

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

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

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

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

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

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

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

impl Ord for i16

pub fn cmp(&self, other: &i16) -> 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

pub fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> 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
    C: Ord,
    A: Ord,
    E: Ord,
    F: Ord,
    I: Ord,
    B: Ord,
    H: Ord,
    D: Ord,
    G: Ord,
    J: Ord + ?Sized, 

pub fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> 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.

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

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

pub 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> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

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

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

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

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

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

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

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

impl Ord for u64

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

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

pub fn cmp(&self, other: &*const T) -> 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

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

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

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

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

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

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

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

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

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

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

pub fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> 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

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

impl Ord for usize

pub fn cmp(&self, other: &usize) -> 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

pub fn cmp(
    &self,
    other: &unsafe 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, H> Ord for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

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

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

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

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

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

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

pub 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, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

pub 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, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

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

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

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

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

pub fn cmp(
    &self,
    other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> 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

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

impl Ord for bool

pub fn cmp(&self, other: &bool) -> 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

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

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

pub fn cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> 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

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

impl Ord for !

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

impl Ord for i32

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

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

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

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

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

impl Ord for String

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

Implementors

impl Ord for Infallible

impl Ord for Ordering

impl Ord for TypeId

impl Ord for Error

impl Ord for PhantomPinned

impl Ord for NonZeroI8

impl Ord for NonZeroI16

impl Ord for NonZeroI32

impl Ord for NonZeroI64

impl Ord for NonZeroI128

impl Ord for NonZeroIsize

impl Ord for NonZeroU8

impl Ord for NonZeroU16

impl Ord for NonZeroU32

impl Ord for NonZeroU64

impl Ord for NonZeroU128

impl Ord for NonZeroUsize

impl Ord for Duration

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

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

impl<Dyn> Ord for DynMetadata<Dyn> where
    Dyn: ?Sized, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Ord for WithdrawReasons

impl Ord for StorageVersion

impl Ord for ProxyType

impl Ord for NposSolution16

impl Ord for ReturnFlags

impl Ord for Conviction

impl<AccountId, Balance, Solution> Ord for SignedSubmission<AccountId, Balance, Solution> where     AccountId: Ord,     Balance: Ord + HasCompact,     Solution: Ord,     RawSolution<Solution>: Ord,

impl<S: Ord> Ord for RawSolution<S>

impl Ord for Public

impl Ord for GrandpaTimeSlot

impl<AccountId: Ord, ProxyType: Ord, BlockNumber: Ord> Ord for ProxyDefinition<AccountId, ProxyType, BlockNumber>

impl<AccountId: Ord, Balance: Ord + HasCompact> Ord for IndividualExposure<AccountId, Balance>

impl<AccountId: Ord, Balance: Ord + HasCompact> Ord for Exposure<AccountId, Balance>

impl Ord for EpochIdentifierPosition

impl<Hash: Ord, Number: Ord> Ord for EpochIdentifier<Hash, Number>

impl<T: Ord> Ord for SlotDuration<T>

impl Ord for SetId

impl Ord for Public

impl Ord for Public

impl Ord for Public

impl Ord for BigUint

impl Ord for FixedI64

impl Ord for FixedI128

impl Ord for FixedU128

impl Ord for Percent

impl Ord for PerU16

impl Ord for Permill

impl Ord for Perbill

impl Ord for Perquintill

impl Ord for RationalInfinite

impl Ord for Rational128

impl Ord for Slot

impl Ord for VRFProof

impl Ord for AccountId32

impl Ord for KeyTypeId

impl Ord for CryptoTypeId

impl Ord for CryptoTypePublicPair

impl Ord for Public

impl Ord for Public

impl Ord for HttpRequestId

impl Ord for Timestamp

impl Ord for Duration

impl Ord for Public

impl Ord for Bytes

impl Ord for OpaquePeerId

impl<'a> Ord for OpaqueDigestItemId<'a>

impl Ord for UintAuthorityId

impl Ord for MultiSigner

impl Ord for StorageKey

impl Ord for TrackedStorageKey

impl Ord for PrefixedStorageKey

impl Ord for StorageData

impl Ord for ChildInfo

impl Ord for ChildTrieParentKeyId

impl Ord for Timestamp

impl<V: Ord> Ord for StorageQuery<V>