Trait nom::lib::std::prelude::v1::rust_2021::PartialOrd

[+] Show declaration

[+] Expand attributes
#[lang = "partial_ord"]pub trait PartialOrd<Rhs = Self>: PartialEq<Rhs> where
    Rhs: ?Sized, {
[+] Expand attributes
#[must_use]    pub fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;

[+] Expand attributes
#[must_use]    pub fn lt(&self, other: &Rhs) -> bool { ... }
[+] Expand attributes
#[must_use]    pub fn le(&self, other: &Rhs) -> bool { ... }
[+] Expand attributes
#[must_use]    pub fn gt(&self, other: &Rhs) -> bool { ... }
[+] Expand attributes
#[must_use]    pub fn ge(&self, other: &Rhs) -> bool { ... }
}

[−] Expand description

Trait for values that can be compared for a sort-order.

The comparison must satisfy, for all a, b and c:

• asymmetry: if a < b then !(a > b), as well as a > b implying !(a < b); and
• transitivity: a < b and b < c implies a < c. The same must hold for both == and >.

Note that these requirements mean that the trait itself must be implemented symmetrically and transitively: if T: PartialOrd<U> and U: PartialOrd<V> then U: PartialOrd<T> and T: PartialOrd<V>.

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.

How can I implement PartialOrd?

PartialOrd only requires implementation of the partial_cmp method, with the others generated from default implementations.

However it remains possible to implement the others separately for types which do not have a total order. For example, for floating point numbers, NaN < 0 == false and NaN >= 0 == false (cf. IEEE 754-2008 section 5.11).

PartialOrd requires your type to be PartialEq.

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.

If your type is Ord, you can implement partial_cmp by using cmp:

use std::cmp::Ordering;

#[derive(Eq)]
struct Person {
    id: u32,
    name: String,
    height: u32,
}

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

impl Ord for Person {
    fn cmp(&self, other: &Self) -> Ordering {
        self.height.cmp(&other.height)
    }
}

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

You may also find it useful to use partial_cmp on your type’s fields. Here is an example of Person types who have a floating-point height field that is the only field to be used for sorting:

use std::cmp::Ordering;

struct Person {
    id: u32,
    name: String,
    height: f64,
}

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

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

Examples

let x : u32 = 0;
let y : u32 = 1;

assert_eq!(x < y, true);
assert_eq!(x.lt(&y), true);

Required methods

[+] Expand attributes

#[must_use]pub fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>[−]

This method returns an ordering between self and other values if one exists.

Examples

use std::cmp::Ordering;

let result = 1.0.partial_cmp(&2.0);
assert_eq!(result, Some(Ordering::Less));

let result = 1.0.partial_cmp(&1.0);
assert_eq!(result, Some(Ordering::Equal));

let result = 2.0.partial_cmp(&1.0);
assert_eq!(result, Some(Ordering::Greater));

When comparison is impossible:

let result = f64::NAN.partial_cmp(&1.0);
assert_eq!(result, None);

Provided methods

[+] Expand attributes

#[must_use]pub fn lt(&self, other: &Rhs) -> bool[−]

This method tests less than (for self and other) and is used by the < operator.

Examples

let result = 1.0 < 2.0;
assert_eq!(result, true);

let result = 2.0 < 1.0;
assert_eq!(result, false);

[+] Expand attributes

#[must_use]pub fn le(&self, other: &Rhs) -> bool[−]

This method tests less than or equal to (for self and other) and is used by the <= operator.

Examples

let result = 1.0 <= 2.0;
assert_eq!(result, true);

let result = 2.0 <= 2.0;
assert_eq!(result, true);

[+] Expand attributes

#[must_use]pub fn gt(&self, other: &Rhs) -> bool[−]

This method tests greater than (for self and other) and is used by the > operator.

Examples

let result = 1.0 > 2.0;
assert_eq!(result, false);

let result = 2.0 > 2.0;
assert_eq!(result, false);

[+] Expand attributes

#[must_use]pub fn ge(&self, other: &Rhs) -> bool[−]

This method tests greater than or equal to (for self and other) and is used by the >= operator.

Examples

let result = 2.0 >= 1.0;
assert_eq!(result, true);

let result = 2.0 >= 2.0;
assert_eq!(result, true);

Implementations on Foreign Types

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl PartialOrd<Ipv6Addr> for IpAddr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>

impl PartialOrd<SocketAddrV4> for SocketAddrV4[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &SocketAddrV4) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for &'a Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl PartialOrd<IpAddr> for IpAddr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>

impl PartialOrd<OsString> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

pub fn lt(&self, other: &OsString) -> bool

pub fn le(&self, other: &OsString) -> bool

pub fn gt(&self, other: &OsString) -> bool

pub fn ge(&self, other: &OsString) -> bool

impl PartialOrd<str> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &str) -> Option<Ordering>

impl PartialOrd<Path> for Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for &'a OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for &'a Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>[−]

[+] Show hidden undocumented items

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

impl<'a, 'b> PartialOrd<PathBuf> for Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'b, OsStr>) -> Option<Ordering>

impl PartialOrd<Ipv4Addr> for Ipv4Addr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>

impl PartialOrd<IpAddr> for Ipv6Addr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>

impl PartialOrd<str> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &str) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a> PartialOrd<Components<'a>> for Components<'a>[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Components<'a>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a OsStr> for Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a OsStr> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl PartialOrd<ErrorKind> for ErrorKind[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &ErrorKind) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl PartialOrd<SocketAddrV6> for SocketAddrV6[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &SocketAddrV6) -> Option<Ordering>

impl<'a> PartialOrd<Component<'a>> for Component<'a>[−]

[+] Show hidden undocumented items

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

impl<'a, 'b> PartialOrd<OsString> for &'a OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl PartialOrd<Ipv4Addr> for IpAddr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl PartialOrd<PathBuf> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for OsString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl PartialOrd<CStr> for CStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &CStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>

impl PartialOrd<IpAddr> for Ipv4Addr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>

impl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PrefixComponent<'a>) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl PartialOrd<CString> for CString[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &CString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for PathBuf[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>

impl PartialOrd<SystemTime> for SystemTime[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering>

impl PartialOrd<Instant> for Instant[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Instant) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for &'a Path[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl PartialOrd<OsStr> for OsStr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

pub fn lt(&self, other: &OsStr) -> bool

pub fn le(&self, other: &OsStr) -> bool

pub fn gt(&self, other: &OsStr) -> bool

pub fn ge(&self, other: &OsStr) -> bool

impl PartialOrd<Ipv6Addr> for Ipv6Addr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>

impl PartialOrd<SocketAddr> for SocketAddr[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &SocketAddr) -> Option<Ordering>

impl PartialOrd<TypeId> for TypeId[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &TypeId) -> Option<Ordering>

impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<Duration> for Duration[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Duration) -> Option<Ordering>

impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: PartialOrd<C> + PartialEq<C>,
    F: PartialOrd<F> + PartialEq<F>,
    E: PartialOrd<E> + PartialEq<E>,
    I: PartialOrd<I> + PartialEq<I>,
    G: PartialOrd<G> + PartialEq<G>,
    H: PartialOrd<H> + PartialEq<H>,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>,
    J: PartialOrd<J> + PartialEq<J>,
    K: PartialOrd<K> + PartialEq<K>,
    L: PartialOrd<L> + PartialEq<L> + ?Sized, [−]

[+] Show hidden undocumented items

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

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

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

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

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

impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &unsafe fn(A) -> Ret) -> Option<Ordering>

impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<i128> for i128[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &i128) -> Option<Ordering>

pub fn lt(&self, other: &i128) -> bool

pub fn le(&self, other: &i128) -> bool

pub fn ge(&self, other: &i128) -> bool

pub fn gt(&self, other: &i128) -> bool

impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>

impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A> PartialOrd<(A,)> for (A,) where
    A: PartialOrd<A> + PartialEq<A> + ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &(A,)) -> Option<Ordering>

pub fn lt(&self, other: &(A,)) -> bool

pub fn le(&self, other: &(A,)) -> bool

pub fn ge(&self, other: &(A,)) -> bool

pub fn gt(&self, other: &(A,)) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret[−]

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroU32> for NonZeroU32[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroU32) -> Option<Ordering>

impl PartialOrd<NonZeroU16> for NonZeroU16[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroU16) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret[−]

[+] Show hidden undocumented items

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

impl<'_, '_, A, B> PartialOrd<&'_ mut B> for &'_ mut A where
    A: PartialOrd<B> + ?Sized,
    B: ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&mut B) -> Option<Ordering>

pub fn lt(&self, other: &&mut B) -> bool

pub fn le(&self, other: &&mut B) -> bool

pub fn gt(&self, other: &&mut B) -> bool

pub fn ge(&self, other: &&mut B) -> bool

impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<()> for ()[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, &()) -> Option<Ordering>

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

[+] Show hidden undocumented items

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

impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<T> PartialOrd<Cell<T>> for Cell<T> where
    T: PartialOrd<T> + Copy, [−]

[+] Show hidden undocumented items

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

pub fn lt(&self, other: &Cell<T>) -> bool

pub fn le(&self, other: &Cell<T>) -> bool

pub fn gt(&self, other: &Cell<T>) -> bool

pub fn ge(&self, other: &Cell<T>) -> bool

impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<i8> for i8[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &i8) -> Option<Ordering>

pub fn lt(&self, other: &i8) -> bool

pub fn le(&self, other: &i8) -> bool

pub fn ge(&self, other: &i8) -> bool

pub fn gt(&self, other: &i8) -> bool

impl<A, B, C, D, E, F, G, H, I, J, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
    C: PartialOrd<C> + PartialEq<C>,
    F: PartialOrd<F> + PartialEq<F>,
    E: PartialOrd<E> + PartialEq<E>,
    I: PartialOrd<I> + PartialEq<I>,
    G: PartialOrd<G> + PartialEq<G>,
    H: PartialOrd<H> + PartialEq<H>,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>,
    J: PartialOrd<J> + PartialEq<J>,
    K: PartialOrd<K> + PartialEq<K> + ?Sized, [−]

[+] Show hidden undocumented items

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

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

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

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

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

impl<Ret, A, B, C, D, E> PartialOrd<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
    C: PartialOrd<C> + PartialEq<C>,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D> + ?Sized, [−]

[+] Show hidden undocumented items

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

pub fn lt(&self, other: &(A, B, C, D)) -> bool

pub fn le(&self, other: &(A, B, C, D)) -> bool

pub fn ge(&self, other: &(A, B, C, D)) -> bool

pub fn gt(&self, other: &(A, B, C, D)) -> bool

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

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<NonZeroU128> for NonZeroU128[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroU128) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A, B, C, D, E, F, G, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
    C: PartialOrd<C> + PartialEq<C>,
    F: PartialOrd<F> + PartialEq<F>,
    E: PartialOrd<E> + PartialEq<E>,
    G: PartialOrd<G> + PartialEq<G>,
    H: PartialOrd<H> + PartialEq<H> + ?Sized,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>, [−]

[+] Show hidden undocumented items

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

pub fn lt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F> PartialOrd<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroI16> for NonZeroI16[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroI16) -> Option<Ordering>

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

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<i64> for i64[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &i64) -> Option<Ordering>

pub fn lt(&self, other: &i64) -> bool

pub fn le(&self, other: &i64) -> bool

pub fn ge(&self, other: &i64) -> bool

pub fn gt(&self, other: &i64) -> bool

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret[−]

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret[−]

[+] Show hidden undocumented items

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

impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
    P: Deref,
    Q: Deref,
    <P as Deref>::Target: PartialOrd<<Q as Deref>::Target>, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Pin<Q>) -> Option<Ordering>

pub fn lt(&self, other: &Pin<Q>) -> bool

pub fn le(&self, other: &Pin<Q>) -> bool

pub fn gt(&self, other: &Pin<Q>) -> bool

pub fn ge(&self, other: &Pin<Q>) -> bool

impl PartialOrd<isize> for isize[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &isize) -> Option<Ordering>

pub fn lt(&self, other: &isize) -> bool

pub fn le(&self, other: &isize) -> bool

pub fn ge(&self, other: &isize) -> bool

pub fn gt(&self, other: &isize) -> bool

impl PartialOrd<NonZeroU8> for NonZeroU8[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroU8) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Dyn> PartialOrd<DynMetadata<Dyn>> for DynMetadata<Dyn> where
    Dyn: ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &DynMetadata<Dyn>) -> Option<Ordering>

impl<A, B, C, D, E, F, G, H, I, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
    C: PartialOrd<C> + PartialEq<C>,
    F: PartialOrd<F> + PartialEq<F>,
    E: PartialOrd<E> + PartialEq<E>,
    I: PartialOrd<I> + PartialEq<I>,
    G: PartialOrd<G> + PartialEq<G>,
    H: PartialOrd<H> + PartialEq<H>,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>,
    J: PartialOrd<J> + PartialEq<J> + ?Sized, [−]

[+] Show hidden undocumented items

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

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

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

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

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

impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<T> PartialOrd<*mut T> for *mut T where
    T: ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &*mut T) -> Option<Ordering>

pub fn lt(&self, other: &*mut T) -> bool

pub fn le(&self, other: &*mut T) -> bool

pub fn gt(&self, other: &*mut T) -> bool

pub fn ge(&self, other: &*mut T) -> bool

impl PartialOrd<NonZeroI128> for NonZeroI128[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroI128) -> Option<Ordering>

impl PartialOrd<NonZeroI32> for NonZeroI32[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroI32) -> Option<Ordering>

impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(
    &self,
    other: &unsafe fn(A, B, C, D) -> Ret
) -> Option<Ordering>

impl PartialOrd<NonZeroI8> for NonZeroI8[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroI8) -> Option<Ordering>

impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<'_, '_, A, B> PartialOrd<&'_ B> for &'_ A where
    A: PartialOrd<B> + ?Sized,
    B: ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&B) -> Option<Ordering>

pub fn lt(&self, other: &&B) -> bool

pub fn le(&self, other: &&B) -> bool

pub fn gt(&self, other: &&B) -> bool

pub fn ge(&self, other: &&B) -> bool

impl PartialOrd<u64> for u64[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &u64) -> Option<Ordering>

pub fn lt(&self, other: &u64) -> bool

pub fn le(&self, other: &u64) -> bool

pub fn ge(&self, other: &u64) -> bool

pub fn gt(&self, other: &u64) -> bool

impl PartialOrd<NonZeroUsize> for NonZeroUsize[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroUsize) -> Option<Ordering>

impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<T> PartialOrd<[T]> for [T] where
    T: PartialOrd<T>, [−]

[−] Expand description

Implements comparison of vectors lexicographically.

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &[T]) -> Option<Ordering>

impl PartialOrd<u8> for u8[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &u8) -> Option<Ordering>

pub fn lt(&self, other: &u8) -> bool

pub fn le(&self, other: &u8) -> bool

pub fn ge(&self, other: &u8) -> bool

pub fn gt(&self, other: &u8) -> bool

impl PartialOrd<i16> for i16[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &i16) -> Option<Ordering>

pub fn lt(&self, other: &i16) -> bool

pub fn le(&self, other: &i16) -> bool

pub fn ge(&self, other: &i16) -> bool

pub fn gt(&self, other: &i16) -> bool

impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[−]

[+] Show hidden undocumented items

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

impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
    T: ?Sized, [−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A, B, C, D, E, F, G, H, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
    C: PartialOrd<C> + PartialEq<C>,
    F: PartialOrd<F> + PartialEq<F>,
    E: PartialOrd<E> + PartialEq<E>,
    I: PartialOrd<I> + PartialEq<I> + ?Sized,
    G: PartialOrd<G> + PartialEq<G>,
    H: PartialOrd<H> + PartialEq<H>,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>, [−]

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<usize> for usize[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &usize) -> Option<Ordering>

pub fn lt(&self, other: &usize) -> bool

pub fn le(&self, other: &usize) -> bool

pub fn ge(&self, other: &usize) -> bool

pub fn gt(&self, other: &usize) -> bool

impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
    T: PartialOrd<T>, [−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G> PartialOrd<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<i32> for i32[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &i32) -> Option<Ordering>

pub fn lt(&self, other: &i32) -> bool

pub fn le(&self, other: &i32) -> bool

pub fn ge(&self, other: &i32) -> bool

pub fn gt(&self, other: &i32) -> bool

impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A, B> PartialOrd<(A, B)> for (A, B) where
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B> + ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &(A, B)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B)) -> bool

pub fn le(&self, other: &(A, B)) -> bool

pub fn ge(&self, other: &(A, B)) -> bool

pub fn gt(&self, other: &(A, B)) -> bool

impl<'a> PartialOrd<Location<'a>> for Location<'a>[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<u32> for u32[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &u32) -> Option<Ordering>

pub fn lt(&self, other: &u32) -> bool

pub fn le(&self, other: &u32) -> bool

pub fn ge(&self, other: &u32) -> bool

pub fn gt(&self, other: &u32) -> bool

impl PartialOrd<u16> for u16[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &u16) -> Option<Ordering>

pub fn lt(&self, other: &u16) -> bool

pub fn le(&self, other: &u16) -> bool

pub fn ge(&self, other: &u16) -> bool

pub fn gt(&self, other: &u16) -> bool

impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<bool> for bool[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &bool) -> Option<Ordering>

impl PartialOrd<PhantomPinned> for PhantomPinned[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PhantomPinned) -> Option<Ordering>

impl<T> PartialOrd<Poll<T>> for Poll<T> where
    T: PartialOrd<T>, [−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret[−]

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroU64> for NonZeroU64[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroU64) -> Option<Ordering>

impl<T> PartialOrd<RefCell<T>> for RefCell<T> where
    T: PartialOrd<T> + ?Sized, [−]

pub fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>[−]

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn lt(&self, other: &RefCell<T>) -> bool[−]

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn le(&self, other: &RefCell<T>) -> bool[−]

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn gt(&self, other: &RefCell<T>) -> bool[−]

Panics

Panics if the value in either RefCell is currently borrowed.

pub fn ge(&self, other: &RefCell<T>) -> bool[−]

Panics

Panics if the value in either RefCell is currently borrowed.

impl<T> PartialOrd<*const T> for *const T where
    T: ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &*const T) -> Option<Ordering>

pub fn lt(&self, other: &*const T) -> bool

pub fn le(&self, other: &*const T) -> bool

pub fn gt(&self, other: &*const T) -> bool

pub fn ge(&self, other: &*const T) -> bool

impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
    T: ?Sized, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<Ordering>

impl PartialOrd<u128> for u128[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &u128) -> Option<Ordering>

pub fn lt(&self, other: &u128) -> bool

pub fn le(&self, other: &u128) -> bool

pub fn ge(&self, other: &u128) -> bool

pub fn gt(&self, other: &u128) -> bool

impl PartialOrd<!> for ![−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, &!) -> Option<Ordering>

impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
    C: PartialOrd<C> + PartialEq<C>,
    F: PartialOrd<F> + PartialEq<F> + ?Sized,
    E: PartialOrd<E> + PartialEq<E>,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &(A, B, C, D, E, F)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn le(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn ge(&self, other: &(A, B, C, D, E, F)) -> bool

pub fn gt(&self, other: &(A, B, C, D, E, F)) -> bool

impl<A, B, C, D, E, F, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
    C: PartialOrd<C> + PartialEq<C>,
    F: PartialOrd<F> + PartialEq<F>,
    E: PartialOrd<E> + PartialEq<E>,
    G: PartialOrd<G> + PartialEq<G> + ?Sized,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>, [−]

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<f64> for f64[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &f64) -> Option<Ordering>

pub fn lt(&self, other: &f64) -> bool

pub fn le(&self, other: &f64) -> bool

pub fn ge(&self, other: &f64) -> bool

pub fn gt(&self, other: &f64) -> bool

impl PartialOrd<NonZeroI64> for NonZeroI64[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroI64) -> Option<Ordering>

impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
    C: PartialOrd<C> + PartialEq<C> + ?Sized,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>, [−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &(A, B, C)) -> Option<Ordering>

pub fn lt(&self, other: &(A, B, C)) -> bool

pub fn le(&self, other: &(A, B, C)) -> bool

pub fn ge(&self, other: &(A, B, C)) -> bool

pub fn gt(&self, other: &(A, B, C)) -> bool

impl PartialOrd<NonZeroIsize> for NonZeroIsize[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NonZeroIsize) -> Option<Ordering>

impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret[−]

[+] Show hidden undocumented items

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

impl PartialOrd<char> for char[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &char) -> Option<Ordering>

pub fn lt(&self, other: &char) -> bool

pub fn le(&self, other: &char) -> bool

pub fn ge(&self, other: &char) -> bool

pub fn gt(&self, other: &char) -> bool

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[−]

[+] Show hidden undocumented items

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

impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
    C: PartialOrd<C> + PartialEq<C>,
    E: PartialOrd<E> + PartialEq<E> + ?Sized,
    A: PartialOrd<A> + PartialEq<A>,
    B: PartialOrd<B> + PartialEq<B>,
    D: PartialOrd<D> + PartialEq<D>, [−]

[+] Show hidden undocumented items

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

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

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

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

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

impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret[−]

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<str> for str[−]

[−] Expand description

Implements comparison operations on strings.

Strings are compared lexicographically by their byte values. This compares 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. Comparing strings according to culturally-accepted standards requires locale-specific data that is outside the scope of the str type.

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &str) -> Option<Ordering>

impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>

impl PartialOrd<f32> for f32[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &f32) -> Option<Ordering>

pub fn lt(&self, other: &f32) -> bool

pub fn le(&self, other: &f32) -> bool

pub fn ge(&self, other: &f32) -> bool

pub fn gt(&self, other: &f32) -> bool

impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>

impl PartialOrd<CpuidResult> for CpuidResult[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &CpuidResult) -> Option<Ordering>

impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret[−]

[+] Show hidden undocumented items

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

impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret[−]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &fn() -> Ret) -> Option<Ordering>

impl<T> PartialOrd<Arc<T>> for Arc<T> where
    T: PartialOrd<T> + ?Sized, [−]

pub fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>[−]

Partial comparison for two Arcs.

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

Examples

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

let five = Arc::new(5);

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

pub fn lt(&self, other: &Arc<T>) -> bool[−]

Less-than comparison for two Arcs.

The two are compared by calling < on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five < Arc::new(6));

pub fn le(&self, other: &Arc<T>) -> bool[−]

‘Less than or equal to’ comparison for two Arcs.

The two are compared by calling <= on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five <= Arc::new(5));

pub fn gt(&self, other: &Arc<T>) -> bool[−]

Greater-than comparison for two Arcs.

The two are compared by calling > on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five > Arc::new(4));

pub fn ge(&self, other: &Arc<T>) -> bool[−]

‘Greater than or equal to’ comparison for two Arcs.

The two are compared by calling >= on their inner values.

Examples

use std::sync::Arc;

let five = Arc::new(5);

assert!(five >= Arc::new(5));

impl<T> PartialOrd<Rc<T>> for Rc<T> where
    T: PartialOrd<T> + ?Sized, [−]

pub fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>[−]

Partial comparison for two Rcs.

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

Examples

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

let five = Rc::new(5);

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

pub fn lt(&self, other: &Rc<T>) -> bool[−]

Less-than comparison for two Rcs.

The two are compared by calling < on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five < Rc::new(6));

pub fn le(&self, other: &Rc<T>) -> bool[−]

‘Less than or equal to’ comparison for two Rcs.

The two are compared by calling <= on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five <= Rc::new(5));

pub fn gt(&self, other: &Rc<T>) -> bool[−]

Greater-than comparison for two Rcs.

The two are compared by calling > on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five > Rc::new(4));

pub fn ge(&self, other: &Rc<T>) -> bool[−]

‘Greater than or equal to’ comparison for two Rcs.

The two are compared by calling >= on their inner values.

Examples

use std::rc::Rc;

let five = Rc::new(5);

assert!(five >= Rc::new(5));

Implementors

impl PartialOrd<Ordering> for Ordering[+]

[+] Show hidden undocumented items

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

impl PartialOrd<Infallible> for Infallible[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, _other: &Infallible) -> Option<Ordering>

impl PartialOrd<Error> for Error[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Error) -> Option<Ordering>

impl PartialOrd<NoneError> for NoneError[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &NoneError) -> Option<Ordering>

impl PartialOrd<String> for String[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &String) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &&'b Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>[+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>

impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
    B: PartialOrd<B> + ToOwned + ?Sized, [+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>

impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
    A: PartialOrd<A>, [+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &VecDeque<A>) -> Option<Ordering>

impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
    K: PartialOrd<K>,
    V: PartialOrd<V>, [+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &BTreeMap<K, V>) -> Option<Ordering>

impl<T> PartialOrd<Option<T>> for Option<T> where
    T: PartialOrd<T>, [+]

[+] Show hidden undocumented items

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

impl<T> PartialOrd<Reverse<T>> for Reverse<T> where
    T: PartialOrd<T>, [+]

[+] Show hidden undocumented items

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

pub fn lt(&self, other: &Reverse<T>) -> bool

pub fn le(&self, other: &Reverse<T>) -> bool

pub fn gt(&self, other: &Reverse<T>) -> bool

pub fn ge(&self, other: &Reverse<T>) -> bool

impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
    T: PartialOrd<T>, [+]

[+] Show hidden undocumented items

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

impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
    T: PartialOrd<T>, [+]

[+] Show hidden undocumented items

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

impl<T> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T> where
    T: PartialOrd<T> + ?Sized, [+]

[+] Show hidden undocumented items

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

impl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
    T: PartialOrd<T> + ?Sized,
    A: Allocator, [+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>

pub fn lt(&self, other: &Box<T, A>) -> bool

pub fn le(&self, other: &Box<T, A>) -> bool

pub fn ge(&self, other: &Box<T, A>) -> bool

pub fn gt(&self, other: &Box<T, A>) -> bool

impl<T, A> PartialOrd<Vec<T, A>> for Vec<T, A> where
    T: PartialOrd<T>,
    A: Allocator, [+]

Implements comparison of vectors, lexicographically.

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Vec<T, A>) -> Option<Ordering>

impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
    E: PartialOrd<E>,
    T: PartialOrd<T>, [+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
    R: PartialOrd<R>,
    Y: PartialOrd<Y>, [+]

[+] Show hidden undocumented items

pub fn partial_cmp(&self, other: &GeneratorState<Y, R>) -> Option<Ordering>

impl<T: PartialOrd> PartialOrd<ConstantDeref<T>> for ConstantDeref<T>

impl<T: PartialOrd> PartialOrd<Constant<T>> for Constant<T>

impl<A: Array<Item = u8>> PartialOrd<ArrayString<A>> for ArrayString<A>

impl<A: Array<Item = u8>> PartialOrd<str> for ArrayString<A>

impl<A: Array<Item = u8>> PartialOrd<ArrayString<A>> for str

impl<T: PartialOrd> PartialOrd<CapacityError<T>> for CapacityError<T>

impl<A: Array> PartialOrd<ArrayVec<A>> for ArrayVec<A> where     A::Item: PartialOrd,

impl PartialOrd<Nanoseconds> for Nanoseconds

impl PartialOrd<BString> for BString

impl<'a, 'b> PartialOrd<Vec<u8, Global>> for BString

impl<'a, 'b> PartialOrd<BString> for Vec<u8>

impl<'a, 'b> PartialOrd<[u8]> for BString

impl<'a, 'b> PartialOrd<BString> for [u8]

impl<'a, 'b> PartialOrd<&'a [u8]> for BString

impl<'a, 'b> PartialOrd<BString> for &'a [u8]

impl<'a, 'b> PartialOrd<String> for BString

impl<'a, 'b> PartialOrd<str> for BString

impl<'a, 'b> PartialOrd<&'a str> for BString

impl<'a, 'b> PartialOrd<BStr> for BString

impl<'a, 'b> PartialOrd<BString> for BStr

impl<'a, 'b> PartialOrd<&'a BStr> for BString

impl<'a, 'b> PartialOrd<BString> for &'a BStr

impl PartialOrd<BStr> for BStr

impl<'a, 'b> PartialOrd<[u8]> for BStr

impl<'a, 'b> PartialOrd<BStr> for [u8]

impl<'a, 'b> PartialOrd<&'a [u8]> for BStr

impl<'a, 'b> PartialOrd<BStr> for &'a [u8]

impl<'a, 'b> PartialOrd<str> for BStr

impl<'a, 'b> PartialOrd<&'a str> for BStr

impl<'a, 'b> PartialOrd<Vec<u8, Global>> for BStr

impl<'a, 'b> PartialOrd<BStr> for Vec<u8>

impl<'a, 'b> PartialOrd<Vec<u8, Global>> for &'a BStr

impl<'a, 'b> PartialOrd<&'a BStr> for Vec<u8>

impl<'a, 'b> PartialOrd<String> for BStr

impl<'a, 'b> PartialOrd<String> for &'a BStr

impl PartialOrd<BigEndian> for BigEndian

impl PartialOrd<LittleEndian> for LittleEndian

impl PartialOrd<Bytes> for Bytes

impl PartialOrd<[u8]> for Bytes

impl PartialOrd<Bytes> for [u8]

impl PartialOrd<str> for Bytes

impl PartialOrd<Vec<u8, Global>> for Bytes

impl PartialOrd<String> for Bytes

impl PartialOrd<Bytes> for &[u8]

impl<'a, T: ?Sized> PartialOrd<&'a T> for Bytes where     Bytes: PartialOrd<T>,

impl PartialOrd<BytesMut> for BytesMut

impl PartialOrd<[u8]> for BytesMut

impl PartialOrd<BytesMut> for [u8]

impl PartialOrd<str> for BytesMut

impl PartialOrd<Vec<u8, Global>> for BytesMut

impl PartialOrd<String> for BytesMut

impl<'a, T: ?Sized> PartialOrd<&'a T> for BytesMut where     BytesMut: PartialOrd<T>,

impl PartialOrd<BytesMut> for &[u8]

impl PartialOrd<PackageId> for PackageId

impl PartialOrd<FeatureGate> for FeatureGate

impl PartialOrd<NaiveDate> for NaiveDate

impl PartialOrd<IsoWeek> for IsoWeek

impl PartialOrd<NaiveTime> for NaiveTime

impl PartialOrd<NaiveDateTime> for NaiveDateTime

impl<Tz: TimeZone> PartialOrd<Date<Tz>> for Date<Tz>

impl<Tz: TimeZone, Tz2: TimeZone> PartialOrd<DateTime<Tz2>> for DateTime<Tz>

impl<'g, T: ?Sized + Pointable> PartialOrd<Shared<'g, T>> for Shared<'g, T>

impl PartialOrd<IdentString> for IdentString

impl PartialOrd<DebugId> for DebugId

impl PartialOrd<CodeId> for CodeId

impl<L: PartialOrd, R: PartialOrd> PartialOrd<Either<L, R>> for Either<L, R>

impl PartialOrd<FileTime> for FileTime

impl<T: PartialOrd> PartialOrd<AllowStdIo<T>> for AllowStdIo<T>

impl<T: PartialOrd, N> PartialOrd<GenericArray<T, N>> for GenericArray<T, N> where     N: ArrayLength<T>,

impl PartialOrd<HeaderValue> for HeaderValue

impl PartialOrd<str> for HeaderValue

impl PartialOrd<[u8]> for HeaderValue

impl PartialOrd<HeaderValue> for str

impl PartialOrd<String> for HeaderValue

impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue

impl<'a, T: ?Sized> PartialOrd<&'a T> for HeaderValue where     HeaderValue: PartialOrd<T>,

impl<'a> PartialOrd<HeaderValue> for &'a str

impl PartialOrd<StatusCode> for StatusCode

impl PartialOrd<Authority> for Authority

impl PartialOrd<str> for Authority

impl PartialOrd<Authority> for str

impl<'a> PartialOrd<Authority> for &'a str

impl<'a> PartialOrd<&'a str> for Authority

impl PartialOrd<String> for Authority

impl PartialOrd<PathAndQuery> for PathAndQuery

impl PartialOrd<str> for PathAndQuery

impl PartialOrd<PathAndQuery> for str

impl<'a> PartialOrd<&'a str> for PathAndQuery

impl<'a> PartialOrd<PathAndQuery> for &'a str

impl PartialOrd<String> for PathAndQuery

impl PartialOrd<Version> for Version

impl PartialOrd<HttpDate> for HttpDate

impl PartialOrd<EventMask> for EventMask

impl PartialOrd<WatchMask> for WatchMask

impl PartialOrd<IpAddrRange> for IpAddrRange

impl PartialOrd<Ipv4AddrRange> for Ipv4AddrRange

impl PartialOrd<Ipv6AddrRange> for Ipv6AddrRange

impl PartialOrd<IpNet> for IpNet

impl PartialOrd<Ipv4Net> for Ipv4Net

impl PartialOrd<Ipv6Net> for Ipv6Net

impl PartialOrd<IpSubnets> for IpSubnets

impl PartialOrd<Ipv4Subnets> for Ipv4Subnets

impl PartialOrd<Ipv6Subnets> for Ipv6Subnets

impl PartialOrd<Ipv4Network> for Ipv4Network

impl PartialOrd<Ipv6Network> for Ipv6Network

impl PartialOrd<IpNetwork> for IpNetwork

impl PartialOrd<NetworkSize> for NetworkSize

impl<T: PartialOrd, E: PartialOrd> PartialOrd<Finish<T, E>> for Finish<T, E>

impl PartialOrd<CompressionLevel> for CompressionLevel

impl PartialOrd<Lz77WindowSize> for Lz77WindowSize

impl<K: Hash + Eq + PartialOrd, V: PartialOrd, S: BuildHasher> PartialOrd<LinkedHashMap<K, V, S>> for LinkedHashMap<K, V, S>

impl PartialOrd<Level> for Level

impl PartialOrd<LevelFilter> for Level

impl PartialOrd<LevelFilter> for LevelFilter

impl PartialOrd<Level> for LevelFilter

impl<'a> PartialOrd<Metadata<'a>> for Metadata<'a>

impl<'a> PartialOrd<MetadataBuilder<'a>> for MetadataBuilder<'a>

impl<'a> PartialOrd<Name<'a>> for Name<'a>

impl PartialOrd<Mime> for Mime

impl PartialOrd<PollOpt> for PollOpt

impl PartialOrd<Ready> for Ready

impl PartialOrd<UnixReady> for UnixReady

impl PartialOrd<Token> for Token

impl PartialOrd<AtFlags> for AtFlags

impl PartialOrd<OFlag> for OFlag

impl PartialOrd<SealFlag> for SealFlag

impl PartialOrd<FdFlag> for FdFlag

impl PartialOrd<SpliceFFlags> for SpliceFFlags

impl PartialOrd<FallocateFlags> for FallocateFlags

impl PartialOrd<PosixFadviseAdvice> for PosixFadviseAdvice

impl PartialOrd<ModuleInitFlags> for ModuleInitFlags

impl PartialOrd<DeleteModuleFlags> for DeleteModuleFlags

impl PartialOrd<MsFlags> for MsFlags

impl PartialOrd<MntFlags> for MntFlags

impl PartialOrd<MQ_OFlag> for MQ_OFlag

impl PartialOrd<FdFlag> for FdFlag

impl PartialOrd<InterfaceFlags> for InterfaceFlags

impl PartialOrd<PollFlags> for PollFlags

impl PartialOrd<CloneFlags> for CloneFlags

impl PartialOrd<AioFsyncMode> for AioFsyncMode

impl PartialOrd<LioOpcode> for LioOpcode

impl PartialOrd<LioMode> for LioMode

impl PartialOrd<EpollFlags> for EpollFlags

impl PartialOrd<EpollCreateFlags> for EpollCreateFlags

impl PartialOrd<EfdFlags> for EfdFlags

impl PartialOrd<MemFdCreateFlag> for MemFdCreateFlag

impl PartialOrd<ProtFlags> for ProtFlags

impl PartialOrd<MapFlags> for MapFlags

impl PartialOrd<MmapAdvise> for MmapAdvise

impl PartialOrd<MsFlags> for MsFlags

impl PartialOrd<MlockAllFlags> for MlockAllFlags

impl PartialOrd<Request> for Request

impl PartialOrd<Event> for Event

impl PartialOrd<Options> for Options

impl PartialOrd<QuotaType> for QuotaType

impl PartialOrd<QuotaFmt> for QuotaFmt

impl PartialOrd<QuotaValidFlags> for QuotaValidFlags

impl PartialOrd<RebootMode> for RebootMode

impl PartialOrd<Signal> for Signal

impl PartialOrd<SaFlags> for SaFlags

impl PartialOrd<SigmaskHow> for SigmaskHow

impl PartialOrd<SfdFlags> for SfdFlags

impl PartialOrd<SockFlag> for SockFlag

impl PartialOrd<MsgFlags> for MsgFlags

impl PartialOrd<SFlag> for SFlag

impl PartialOrd<Mode> for Mode

impl PartialOrd<FsFlags> for FsFlags

impl PartialOrd<BaudRate> for BaudRate

impl PartialOrd<SetArg> for SetArg

impl PartialOrd<FlushArg> for FlushArg

impl PartialOrd<FlowArg> for FlowArg

impl PartialOrd<SpecialCharacterIndices> for SpecialCharacterIndices

impl PartialOrd<InputFlags> for InputFlags

impl PartialOrd<OutputFlags> for OutputFlags

impl PartialOrd<ControlFlags> for ControlFlags

impl PartialOrd<LocalFlags> for LocalFlags

impl PartialOrd<TimeSpec> for TimeSpec

impl PartialOrd<TimeVal> for TimeVal

impl PartialOrd<WaitPidFlag> for WaitPidFlag

impl PartialOrd<AddWatchFlags> for AddWatchFlags

impl PartialOrd<InitFlags> for InitFlags

impl PartialOrd<WatchDescriptor> for WatchDescriptor

impl PartialOrd<ClockId> for ClockId

impl PartialOrd<TimerFlags> for TimerFlags

impl PartialOrd<TimerSetTimeFlags> for TimerSetTimeFlags

impl PartialOrd<ClockId> for ClockId

impl PartialOrd<Pid> for Pid

impl PartialOrd<AccessFlags> for AccessFlags

impl PartialOrd<Op> for Op

impl PartialOrd<RecursiveMode> for RecursiveMode

impl PartialOrd<Locale> for Locale

impl<'a> PartialOrd<DecimalStr<'a>> for DecimalStr<'a>

impl<'a> PartialOrd<InfinityStr<'a>> for InfinityStr<'a>

impl<'a> PartialOrd<MinusSignStr<'a>> for MinusSignStr<'a>

impl<'a> PartialOrd<NanStr<'a>> for NanStr<'a>

impl<'a> PartialOrd<PlusSignStr<'a>> for PlusSignStr<'a>

impl<'a> PartialOrd<SeparatorStr<'a>> for SeparatorStr<'a>

impl<T: Clone + Integer> PartialOrd<Ratio<T>> for Ratio<T>

impl PartialOrd<Asn1TimeRef> for Asn1TimeRef

impl PartialOrd<Asn1Time> for Asn1TimeRef

impl<'a> PartialOrd<Asn1Time> for &'a Asn1TimeRef

impl PartialOrd<Asn1Time> for Asn1Time

impl PartialOrd<Asn1TimeRef> for Asn1Time

impl<'a> PartialOrd<&'a Asn1TimeRef> for Asn1Time

impl PartialOrd<BigNumRef> for BigNumRef

impl PartialOrd<BigNum> for BigNumRef

impl PartialOrd<BigNum> for BigNum

impl PartialOrd<BigNumRef> for BigNum

impl PartialOrd<CMSOptions> for CMSOptions

impl PartialOrd<OcspFlag> for OcspFlag

impl PartialOrd<Pkcs7Flags> for Pkcs7Flags

impl PartialOrd<SslOptions> for SslOptions

impl PartialOrd<SslMode> for SslMode

impl PartialOrd<SslVerifyMode> for SslVerifyMode

impl PartialOrd<SslSessionCacheMode> for SslSessionCacheMode

impl PartialOrd<ExtensionContext> for ExtensionContext

impl PartialOrd<ShutdownState> for ShutdownState

impl PartialOrd<X509CheckFlags> for X509CheckFlags

impl<T: Float> PartialOrd<OrderedFloat<T>> for OrderedFloat<T>

impl<T: PartialOrd + Float> PartialOrd<NotNan<T>> for NotNan<T>

impl<'i> PartialOrd<Position<'i>> for Position<'i>

impl PartialOrd<MacAddr> for MacAddr

impl PartialOrd<Ident> for Ident

impl PartialOrd<NFSServerCaps> for NFSServerCaps

impl PartialOrd<StatFlags> for StatFlags

impl PartialOrd<CoredumpFlags> for CoredumpFlags

impl PartialOrd<FDPermissions> for FDPermissions

impl PartialOrd<Version> for Version

impl PartialOrd<LabelPair> for LabelPair

impl PartialOrd<Chars> for Chars

impl PartialOrd<ObserveID> for ObserveID

impl PartialOrd<PeerTicks> for PeerTicks

impl PartialOrd<ProposalContext> for ProposalContext

impl PartialOrd<SnapKey> for SnapKey

impl PartialOrd<KeyEntry> for KeyEntry

impl PartialOrd<Span> for Span

impl PartialOrd<Position> for Position

impl PartialOrd<Literal> for Literal

impl PartialOrd<ClassUnicodeRange> for ClassUnicodeRange

impl PartialOrd<ClassBytesRange> for ClassBytesRange

impl PartialOrd<Utf8Sequence> for Utf8Sequence

impl PartialOrd<Utf8Range> for Utf8Range

impl<ComponentType: PartialOrd> PartialOrd<BGR<ComponentType>> for BGR<ComponentType>

impl<ComponentType: PartialOrd, AlphaComponentType: PartialOrd> PartialOrd<BGRA<ComponentType, AlphaComponentType>> for BGRA<ComponentType, AlphaComponentType>

impl<ComponentType: PartialOrd> PartialOrd<Gray<ComponentType>> for Gray<ComponentType>

impl<ComponentType: PartialOrd, AlphaComponentType: PartialOrd> PartialOrd<GrayAlpha<ComponentType, AlphaComponentType>> for GrayAlpha<ComponentType, AlphaComponentType>

impl<ComponentType: PartialOrd> PartialOrd<RGB<ComponentType>> for RGB<ComponentType>

impl<ComponentType: PartialOrd, AlphaComponentType: PartialOrd> PartialOrd<RGBA<ComponentType, AlphaComponentType>> for RGBA<ComponentType, AlphaComponentType>

impl PartialOrd<Identifier> for Identifier

impl PartialOrd<SemVerError> for SemVerError

impl PartialOrd<Version> for Version

impl PartialOrd<VersionReq> for VersionReq

impl PartialOrd<RangeSet> for RangeSet

impl PartialOrd<Compat> for Compat

impl PartialOrd<Range> for Range

impl PartialOrd<Comparator> for Comparator

impl PartialOrd<Op> for Op

impl PartialOrd<Identifier> for Identifier

impl<'input> PartialOrd<Token<'input>> for Token<'input>

impl PartialOrd<Error> for Error

impl<'input> PartialOrd<Error<'input>> for Error<'input>

impl PartialOrd<Version> for Version

impl PartialOrd<Identifier> for Identifier

impl<Sep: PartialOrd> PartialOrd<StringWithSeparator<Sep>> for StringWithSeparator<Sep>

impl PartialOrd<SpaceSeparator> for SpaceSeparator

impl PartialOrd<CommaSeparator> for CommaSeparator

impl PartialOrd<SigId> for SigId

impl PartialOrd<Level> for Level

impl PartialOrd<FilterLevel> for FilterLevel

impl PartialOrd<OverflowStrategy> for OverflowStrategy

impl<A: Array> PartialOrd<SmallVec<A>> for SmallVec<A> where     A::Item: PartialOrd,

impl PartialOrd<CpuFamily> for CpuFamily

impl PartialOrd<Arch> for Arch

impl PartialOrd<Language> for Language

impl PartialOrd<NameMangling> for NameMangling

impl PartialOrd<Lifetime> for Lifetime

impl PartialOrd<Signal> for Signal

impl PartialOrd<User> for User

impl PartialOrd<DiskUsage> for DiskUsage

impl PartialOrd<FieldTypeFlag> for FieldTypeFlag

impl<T, C: Collator> PartialOrd<SortKey<T, C>> for SortKey<T, C> where     T: AsRef<[u8]>,

impl<'a> PartialOrd<ScalarValueRef<'a>> for ScalarValueRef<'a>

impl PartialOrd<BinaryLiteral> for BinaryLiteral

impl PartialOrd<Decimal> for Decimal

impl PartialOrd<Duration> for Duration

impl PartialOrd<Enum> for Enum

impl<'a> PartialOrd<EnumRef<'a>> for EnumRef<'a>

impl<'a> PartialOrd<JsonRef<'a>> for JsonRef<'a>

impl PartialOrd<Json> for Json

impl PartialOrd<Set> for Set

impl<'a> PartialOrd<SetRef<'a>> for SetRef<'a>

impl PartialOrd<WeekMode> for WeekMode

impl PartialOrd<Time> for Time

impl PartialOrd<Flags> for Flags

impl PartialOrd<SqlMode> for SqlMode

impl PartialOrd<Flag> for Flag

impl PartialOrd<HeapItemUnsafe> for HeapItemUnsafe

impl PartialOrd<UnixSecs> for UnixSecs

impl PartialOrd<Instant> for Instant

impl<T> PartialOrd<TimeoutTask<T>> for TimeoutTask<T>

impl PartialOrd<Date> for Date

impl PartialOrd<Duration> for Duration

impl PartialOrd<Duration> for Duration

impl PartialOrd<Format> for Format

impl PartialOrd<Instant> for Instant

impl PartialOrd<Instant> for Instant

impl PartialOrd<OffsetDateTime> for OffsetDateTime

impl PartialOrd<SystemTime> for OffsetDateTime

impl PartialOrd<PrimitiveDateTime> for PrimitiveDateTime

impl PartialOrd<SystemTime> for PrimitiveDateTime

impl PartialOrd<Time> for Time

impl PartialOrd<UtcOffset> for UtcOffset

impl PartialOrd<Instant> for Instant

impl PartialOrd<BytesCodec> for BytesCodec

impl PartialOrd<LinesCodec> for LinesCodec

impl PartialOrd<Level> for Level

impl PartialOrd<LevelFilter> for Level

impl PartialOrd<LevelFilter> for LevelFilter

impl PartialOrd<Level> for LevelFilter

impl PartialOrd<TimeStamp> for TimeStamp

impl PartialOrd<Key> for Key

impl PartialOrd<WriteBatchFlags> for WriteBatchFlags

impl PartialOrd<B0> for B0

impl PartialOrd<B1> for B1

impl<U: PartialOrd + Unsigned + NonZero> PartialOrd<PInt<U>> for PInt<U>

impl<U: PartialOrd + Unsigned + NonZero> PartialOrd<NInt<U>> for NInt<U>

impl PartialOrd<Z0> for Z0

impl PartialOrd<UTerm> for UTerm

impl<U: PartialOrd, B: PartialOrd> PartialOrd<UInt<U, B>> for UInt<U, B>

impl PartialOrd<ATerm> for ATerm

impl<V: PartialOrd, A: PartialOrd> PartialOrd<TArr<V, A>> for TArr<V, A>

impl PartialOrd<Greater> for Greater

impl PartialOrd<Less> for Less

impl PartialOrd<Equal> for Equal

impl<T: AsRef<str>> PartialOrd<Ascii<T>> for Ascii<T>

impl<T: AsRef<str>> PartialOrd<UniCase<T>> for UniCase<T>

impl PartialOrd<Level> for Level

impl<S: PartialOrd> PartialOrd<Host<S>> for Host<S>

impl PartialOrd<Url> for Url

impl PartialOrd<Hyphenated> for Hyphenated

impl<'a> PartialOrd<HyphenatedRef<'a>> for HyphenatedRef<'a>

impl PartialOrd<Simple> for Simple

impl<'a> PartialOrd<SimpleRef<'a>> for SimpleRef<'a>

impl PartialOrd<Urn> for Urn

impl<'a> PartialOrd<UrnRef<'a>> for UrnRef<'a>

impl PartialOrd<Uuid> for Uuid

impl<V: PartialOrd> PartialOrd<VecMap<V>> for VecMap<V>