Trait wasmer_types::entity::__core::cmp::PartialOrd

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

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

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

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

Loading content...

Provided methods

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

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

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

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

Loading content...

Implementations on Foreign Types

impl<'a, 'b> PartialOrd<PathBuf> for OsString

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

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

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

impl PartialOrd<Path> for Path

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

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

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

impl<'a, 'b> PartialOrd<OsStr> for Path

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

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

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

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

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

impl<'a, 'b> PartialOrd<Path> for OsString

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

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

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

impl PartialOrd<IpAddr> for Ipv6Addr

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

impl PartialOrd<Instant> for Instant

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

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

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

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

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

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

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

impl PartialOrd<Ipv4Addr> for IpAddr

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<OsString> for OsString

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<'a, 'b> PartialOrd<Path> for OsStr

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

impl PartialOrd<ErrorKind> for ErrorKind

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

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

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

impl PartialOrd<IpAddr> for IpAddr

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

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

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

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

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

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

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

impl PartialOrd<SocketAddr> for SocketAddr

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

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

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

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

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

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

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

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

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

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

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

impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>

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

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

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

impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr

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

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

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

impl<'a, 'b> PartialOrd<OsString> for Path

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

impl PartialOrd<PathBuf> for PathBuf

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

impl PartialOrd<SocketAddrV6> for SocketAddrV6

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

impl<'a, 'b> PartialOrd<OsString> for OsStr

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

impl PartialOrd<str> for OsString

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

impl PartialOrd<CString> for CString

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

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

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

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

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

impl<'a, 'b> PartialOrd<Path> for PathBuf

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

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

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

impl PartialOrd<Ipv6Addr> for IpAddr

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

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

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

impl PartialOrd<SystemTime> for SystemTime

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

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

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

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

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

impl<'a, 'b> PartialOrd<OsStr> for OsString

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

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

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

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

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

impl<'a, 'b> PartialOrd<OsStr> for PathBuf

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

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

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

impl<'a> PartialOrd<Component<'a>> for Component<'a>

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

pub fn lt(&self, other: &Component<'a>) -> bool

pub fn le(&self, other: &Component<'a>) -> bool

pub fn gt(&self, other: &Component<'a>) -> bool

pub fn ge(&self, other: &Component<'a>) -> bool

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

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

impl PartialOrd<Ipv6Addr> for Ipv6Addr

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

impl PartialOrd<SocketAddrV4> for SocketAddrV4

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

impl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>

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

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

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

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

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

impl<'a, 'b> PartialOrd<PathBuf> for Path

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

impl PartialOrd<OsStr> for OsStr

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<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>

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

impl PartialOrd<CStr> for CStr

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

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

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

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

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

impl<'a> PartialOrd<Components<'a>> for Components<'a>

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

impl<'a, 'b> PartialOrd<OsString> for PathBuf

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

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

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

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

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

impl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>

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

pub fn lt(&self, other: &Prefix<'a>) -> bool

pub fn le(&self, other: &Prefix<'a>) -> bool

pub fn gt(&self, other: &Prefix<'a>) -> bool

pub fn ge(&self, other: &Prefix<'a>) -> bool

impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>

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

impl PartialOrd<Ipv4Addr> for Ipv4Addr

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

impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path

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

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

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

impl PartialOrd<IpAddr> for Ipv4Addr

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

impl<'a, 'b> PartialOrd<PathBuf> for OsStr

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

impl PartialOrd<str> for OsStr

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

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

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

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

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<A, B> PartialOrd<(A, B)> for (A, B) where
    A: PartialEq<A> + PartialOrd<A>,
    B: PartialEq<B> + PartialOrd<B> + ?Sized, 

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 PartialOrd<usize> for usize

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

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

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

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

impl PartialOrd<i8> for i8

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

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

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

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> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

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

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

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

impl PartialOrd<u8> for u8

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<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

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

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 PartialOrd<i16> for i16

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

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> 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: PartialEq<C> + PartialOrd<C>,
    A: PartialEq<A> + PartialOrd<A>,
    H: PartialEq<H> + PartialOrd<H>,
    E: PartialEq<E> + PartialOrd<E>,
    B: PartialEq<B> + PartialOrd<B>,
    D: PartialEq<D> + PartialOrd<D>,
    F: PartialEq<F> + PartialOrd<F>,
    G: PartialEq<G> + PartialOrd<G>,
    I: PartialEq<I> + PartialOrd<I> + ?Sized, 

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

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

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

impl PartialOrd<isize> for isize

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

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

impl PartialOrd<char> for char

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> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret

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

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: PartialEq<C> + PartialOrd<C>,
    A: PartialEq<A> + PartialOrd<A>,
    H: PartialEq<H> + PartialOrd<H>,
    E: PartialEq<E> + PartialOrd<E>,
    K: PartialEq<K> + PartialOrd<K> + ?Sized,
    B: PartialEq<B> + PartialOrd<B>,
    D: PartialEq<D> + PartialOrd<D>,
    F: PartialEq<F> + PartialOrd<F>,
    G: PartialEq<G> + PartialOrd<G>,
    I: PartialEq<I> + PartialOrd<I>,
    J: PartialEq<J> + PartialOrd<J>, 

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> PartialOrd<fn() -> Ret> for fn() -> Ret

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

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

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

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

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

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

impl PartialOrd<u32> for u32

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<T> PartialOrd<*const T> for *const T where
    T: ?Sized, 

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

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

pub fn partial_cmp(
    &self,
    other: &fn(A, B, C, D, E, F, G) -> 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: PartialEq<C> + PartialOrd<C>,
    A: PartialEq<A> + PartialOrd<A>,
    E: PartialEq<E> + PartialOrd<E>,
    B: PartialEq<B> + PartialOrd<B>,
    D: PartialEq<D> + PartialOrd<D>,
    F: PartialEq<F> + PartialOrd<F> + ?Sized, 

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<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

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

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

impl PartialOrd<bool> for bool

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

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

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

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

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

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

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

impl PartialOrd<()> for ()

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn partial_cmp(
    &self,
    other: &extern "C" fn(A, B, C, D, E, F, G) -> 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: PartialEq<C> + PartialOrd<C>,
    A: PartialEq<A> + PartialOrd<A>,
    H: PartialEq<H> + PartialOrd<H> + ?Sized,
    E: PartialEq<E> + PartialOrd<E>,
    B: PartialEq<B> + PartialOrd<B>,
    D: PartialEq<D> + PartialOrd<D>,
    F: PartialEq<F> + PartialOrd<F>,
    G: PartialEq<G> + PartialOrd<G>, 

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

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

impl PartialOrd<str> for str

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.

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

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

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

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

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

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> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

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

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

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

impl PartialOrd<f64> for f64

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

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

impl PartialOrd<u128> for u128

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

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

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

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

impl PartialOrd<f32> for f32

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

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

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

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> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret

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

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

impl PartialOrd<u16> for u16

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 PartialOrd<i64> for i64

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

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

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

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

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

impl PartialOrd<i128> for i128

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

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

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

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

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

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<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret

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

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

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

impl PartialOrd<!> for !

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

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

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

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

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

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> PartialOrd<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret

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

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

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, 

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

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<[T]> for [T] where
    T: PartialOrd<T>, 

Implements comparison of vectors lexicographically.

pub fn partial_cmp(&self, other: &[T]) -> 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

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

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

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

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

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

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<A> PartialOrd<(A,)> for (A,) where
    A: PartialEq<A> + PartialOrd<A> + ?Sized, 

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

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<*mut T> for *mut T where
    T: ?Sized, 

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

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> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

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

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

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

impl PartialOrd<u64> for u64

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

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

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

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

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<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: PartialEq<C> + PartialOrd<C>,
    A: PartialEq<A> + PartialOrd<A>,
    E: PartialEq<E> + PartialOrd<E>,
    B: PartialEq<B> + PartialOrd<B>,
    D: PartialEq<D> + PartialOrd<D>,
    F: PartialEq<F> + PartialOrd<F>,
    G: PartialEq<G> + PartialOrd<G> + ?Sized, 

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<i32> for i32

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<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
    A: PartialOrd<A>, 

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<String> for String

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

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

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

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

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

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, A> PartialOrd<Box<T, A>> for Box<T, A> where
    T: PartialOrd<T> + ?Sized,
    A: Allocator, 

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<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
    B: PartialOrd<B> + ToOwned + ?Sized, 

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

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

Implements comparison of vectors, lexicographically.

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

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

Loading content...

Implementors

impl PartialOrd<Ordering> for Ordering

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

impl PartialOrd<Infallible> for Infallible

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

impl PartialOrd<ExportIndex> for ExportIndex

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

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

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

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

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

impl PartialOrd<ImportIndex> for ImportIndex

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

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

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

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

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

impl PartialOrd<TypeId> for TypeId

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

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

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

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

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

impl PartialOrd<CpuidResult> for CpuidResult

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

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

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

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

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

impl PartialOrd<Error> for Error

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

impl PartialOrd<PhantomPinned> for PhantomPinned

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

impl PartialOrd<NonZeroI8> for NonZeroI8

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

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

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

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

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

impl PartialOrd<NonZeroI16> for NonZeroI16

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

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

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

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

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

impl PartialOrd<NonZeroI32> for NonZeroI32

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

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

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

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

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

impl PartialOrd<NonZeroI64> for NonZeroI64

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

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

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

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

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

impl PartialOrd<NonZeroI128> for NonZeroI128

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

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

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

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

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

impl PartialOrd<NonZeroIsize> for NonZeroIsize

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

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

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

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

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

impl PartialOrd<NonZeroU8> for NonZeroU8

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

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

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

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

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

impl PartialOrd<NonZeroU16> for NonZeroU16

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

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

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

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

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

impl PartialOrd<NonZeroU32> for NonZeroU32

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

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

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

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

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

impl PartialOrd<NonZeroU64> for NonZeroU64

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

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

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

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

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

impl PartialOrd<NonZeroU128> for NonZeroU128

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

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

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

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

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

impl PartialOrd<NonZeroUsize> for NonZeroUsize

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

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

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

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

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

impl PartialOrd<NoneError> for NoneError

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

impl PartialOrd<Duration> for Duration

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

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

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

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

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

impl PartialOrd<Bytes> for Bytes

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

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

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

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

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

impl PartialOrd<CustomSectionIndex> for CustomSectionIndex

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

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

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

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

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

impl PartialOrd<DataIndex> for DataIndex

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

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

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

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

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

impl PartialOrd<ElemIndex> for ElemIndex

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

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

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

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

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

impl PartialOrd<FunctionIndex> for FunctionIndex

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

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

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

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

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

impl PartialOrd<GlobalIndex> for GlobalIndex

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

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

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

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

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

impl PartialOrd<LocalFunctionIndex> for LocalFunctionIndex

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

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

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

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

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

impl PartialOrd<LocalGlobalIndex> for LocalGlobalIndex

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

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

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

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

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

impl PartialOrd<LocalMemoryIndex> for LocalMemoryIndex

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

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

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

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

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

impl PartialOrd<LocalTableIndex> for LocalTableIndex

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

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

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

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

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

impl PartialOrd<MemoryIndex> for MemoryIndex

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

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

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

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

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

impl PartialOrd<Pages> for Pages

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

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

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

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

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

impl PartialOrd<SignatureIndex> for SignatureIndex

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

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

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

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

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

impl PartialOrd<TableIndex> for TableIndex

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

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

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

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

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

impl<'a> PartialOrd<Location<'a>> for Location<'a>

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

pub fn lt(&self, other: &Location<'a>) -> bool

pub fn le(&self, other: &Location<'a>) -> bool

pub fn gt(&self, other: &Location<'a>) -> bool

pub fn ge(&self, other: &Location<'a>) -> bool

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

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<T> PartialOrd<Option<T>> for Option<T> where
    T: PartialOrd<T>, 

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

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

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

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

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

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

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

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

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

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

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

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

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<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<Reverse<T>> for Reverse<T> where
    T: PartialOrd<T>, 

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<PhantomData<T>> for PhantomData<T> where
    T: ?Sized, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> PartialOrd<PackedOption<T>> for PackedOption<T> where
    T: ReservedValue + PartialOrd<T>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn lt(&self, other: &GeneratorState<Y, R>) -> bool

pub fn le(&self, other: &GeneratorState<Y, R>) -> bool

pub fn gt(&self, other: &GeneratorState<Y, R>) -> bool

pub fn ge(&self, other: &GeneratorState<Y, R>) -> bool

Loading content...