Trait af_lib::prelude::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 OsStr

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

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

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

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

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

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

impl PartialOrd<str> for OsString

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

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

pub fn partial_cmp(&self, other: &Cow<'a, 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 PartialOrd<ErrorKind> for ErrorKind

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

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

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

impl PartialOrd<Path> for Path

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

impl PartialOrd<SocketAddrV6> for SocketAddrV6

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

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

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

impl PartialOrd<Ipv4Addr> for IpAddr

pub fn partial_cmp(&self, other: &Ipv4Addr) -> 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 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<Cow<'a, Path>> for &'b OsStr

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

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

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

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

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

impl PartialOrd<Ipv4Addr> for Ipv4Addr

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

impl PartialOrd<CStr> for CStr

pub fn partial_cmp(&self, other: &CStr) -> 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<&'a Path> for PathBuf

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

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

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

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

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

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

pub fn partial_cmp(&self, other: &PrefixComponent<'a>) -> 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<&'a Path> for OsString

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

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

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

impl PartialOrd<IpAddr> for Ipv4Addr

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

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

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

impl PartialOrd<Ipv6Addr> for IpAddr

pub fn partial_cmp(&self, other: &Ipv6Addr) -> 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<PathBuf> for &'a Path

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

impl PartialOrd<PathBuf> for PathBuf

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

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 PartialOrd<str> for OsStr

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

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

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

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

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<Path> for PathBuf

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

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

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

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

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

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

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

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

impl PartialOrd<IpAddr> for Ipv6Addr

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

impl PartialOrd<Ipv6Addr> for Ipv6Addr

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

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

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

impl PartialOrd<SocketAddrV4> for SocketAddrV4

pub fn partial_cmp(&self, other: &SocketAddrV4) -> 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<'a, 'b> PartialOrd<&'a OsStr> for Path

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

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

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

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

pub fn partial_cmp(&self, other: &Cow<'b, 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<Cow<'a, Path>> for OsStr

pub fn partial_cmp(&self, other: &Cow<'a, Path>) -> 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<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<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<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>,
    E: PartialEq<E> + PartialOrd<E>,
    B: PartialEq<B> + PartialOrd<B>,
    A: PartialEq<A> + PartialOrd<A>,
    D: PartialEq<D> + PartialOrd<D>,
    F: PartialEq<F> + PartialOrd<F>,
    G: PartialEq<G> + PartialOrd<G>,
    I: PartialEq<I> + PartialOrd<I>,
    K: PartialEq<K> + PartialOrd<K> + ?Sized,
    J: PartialEq<J> + PartialOrd<J>,
    H: PartialEq<H> + PartialOrd<H>, 

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

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

impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
    C: PartialEq<C> + PartialOrd<C>,
    B: PartialEq<B> + PartialOrd<B>,
    A: PartialEq<A> + PartialOrd<A>,
    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, B> PartialOrd<&'_ mut B> for &'_ mut A where
    B: ?Sized,
    A: PartialOrd<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<A, B> PartialOrd<(A, B)> for (A, B) where
    B: PartialEq<B> + PartialOrd<B> + ?Sized,
    A: PartialEq<A> + PartialOrd<A>, 

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

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

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

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

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<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, 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<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, 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, 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> 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, 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> 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> 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, 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 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<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>,
    E: PartialEq<E> + PartialOrd<E>,
    B: PartialEq<B> + PartialOrd<B>,
    A: PartialEq<A> + PartialOrd<A>,
    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,
    H: PartialEq<H> + PartialOrd<H>, 

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

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

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

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

pub fn partial_cmp(&self, &()) -> 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<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<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<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<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> 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<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, 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<NoneError> for NoneError

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

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

pub fn partial_cmp(&self, &!) -> 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

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

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

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

pub fn partial_cmp(&self, other: &fn(A) -> 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>,
    E: PartialEq<E> + PartialOrd<E>,
    B: PartialEq<B> + PartialOrd<B>,
    A: PartialEq<A> + PartialOrd<A>,
    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, 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, 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<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<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
    E: PartialOrd<E>,
    T: PartialOrd<T>, 

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

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

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

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

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

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<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<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<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
    V: PartialOrd<V>,
    K: PartialOrd<K>, 

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

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

pub fn partial_cmp(&self, other: &VecDeque<A>) -> 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, 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<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
    T: PartialOrd<T>, 

pub fn partial_cmp(&self, other: &LinkedList<T>) -> 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<AssertAsync<T>> for AssertAsync<T> where
    T: PartialOrd<T>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<LevelFilter> for LevelFilter

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

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

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

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

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

impl PartialOrd<Level> for LevelFilter

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<SigId> for SigId

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

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

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

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

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

impl PartialOrd<Attribute> for Attribute

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

impl PartialOrd<Char> for char

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

impl PartialOrd<Span> for Span

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

impl PartialOrd<Utf8Sequence> for Utf8Sequence

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

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

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

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

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

impl PartialOrd<ClassBytesRange> for ClassBytesRange

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

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

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

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

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

impl PartialOrd<Position> for Position

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

impl PartialOrd<Literal> for Literal

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

impl PartialOrd<ClassUnicodeRange> for ClassUnicodeRange

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

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

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

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

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

impl PartialOrd<Utf8Range> for Utf8Range

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

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

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

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

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

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

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

Compare two DateTimes based on their true time, ignoring time zones

Example

use chrono::prelude::*;

let earlier = Utc.ymd(2015, 5, 15).and_hms(2, 0, 0).with_timezone(&FixedOffset::west(1 * 3600));
let later   = Utc.ymd(2015, 5, 15).and_hms(3, 0, 0).with_timezone(&FixedOffset::west(5 * 3600));

assert_eq!(earlier.to_string(), "2015-05-15 01:00:00 -01:00");
assert_eq!(later.to_string(), "2015-05-14 22:00:00 -05:00");

assert!(later > earlier);

impl PartialOrd<NaiveDate> for NaiveDate

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

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

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

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

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

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

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

impl PartialOrd<IsoWeek> for IsoWeek

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

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

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

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

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

impl PartialOrd<NaiveTime> for NaiveTime

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

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

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

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

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

impl PartialOrd<NaiveDateTime> for NaiveDateTime

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

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

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

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

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

impl PartialOrd<SteadyTime> for SteadyTime

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

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

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

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

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

impl PartialOrd<Timespec> for Timespec

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

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

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

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

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

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

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

impl PartialOrd<Sign> for Sign

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

impl PartialOrd<BigInt> for BigInt

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

impl PartialOrd<BigUint> for BigUint

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

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

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

impl PartialOrd<Uuid> for Uuid

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

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

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

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

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

impl PartialOrd<Simple> for Simple

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Urn> for Urn

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

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

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

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

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

impl PartialOrd<Hyphenated> for Hyphenated

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<BigEndian> for BigEndian

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

impl PartialOrd<LittleEndian> for LittleEndian

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

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

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

impl PartialOrd<BytesMut> for [u8]

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

impl PartialOrd<Bytes> for Bytes

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

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

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

impl PartialOrd<BytesMut> for str

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

impl<'_> PartialOrd<BytesMut> for &'_ [u8]

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

impl PartialOrd<BytesMut> for String

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

impl PartialOrd<Bytes> for String

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

impl PartialOrd<BytesMut> for BytesMut

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

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

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

impl PartialOrd<[u8]> for BytesMut

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

impl<'_> PartialOrd<Bytes> for &'_ [u8]

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

impl PartialOrd<[u8]> for Bytes

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

impl PartialOrd<Bytes> for str

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

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

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

impl PartialOrd<String> for Bytes

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

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

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

impl PartialOrd<str> for Bytes

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

impl<'_> PartialOrd<BytesMut> for &'_ str

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

impl PartialOrd<str> for BytesMut

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

impl PartialOrd<Bytes> for [u8]

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

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

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

impl<'_> PartialOrd<Bytes> for &'_ str

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

impl PartialOrd<String> for BytesMut

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

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

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

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

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

pub fn lt(&self, other: &NInt<U>) -> bool

pub fn le(&self, other: &NInt<U>) -> bool

pub fn gt(&self, other: &NInt<U>) -> bool

pub fn ge(&self, other: &NInt<U>) -> bool

impl PartialOrd<B1> for B1

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

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

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

pub fn lt(&self, other: &PInt<U>) -> bool

pub fn le(&self, other: &PInt<U>) -> bool

pub fn gt(&self, other: &PInt<U>) -> bool

pub fn ge(&self, other: &PInt<U>) -> bool

impl PartialOrd<ATerm> for ATerm

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

impl PartialOrd<UTerm> for UTerm

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

impl PartialOrd<Z0> for Z0

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

impl PartialOrd<B0> for B0

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

impl PartialOrd<Equal> for Equal

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

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

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Less> for Less

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

impl PartialOrd<Greater> for Greater

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

impl PartialOrd<Level> for Level

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

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

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

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

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

impl<A> PartialOrd<TinyVec<A>> for TinyVec<A> where
    A: Array,
    <A as Array>::Item: PartialOrd<<A as Array>::Item>, 

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

impl<'s, T> PartialOrd<SliceVec<'s, T>> for SliceVec<'s, T> where
    T: PartialOrd<T>, 

#[must_use]pub fn partial_cmp(&self, other: &SliceVec<'s, T>) -> Option<Ordering>

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

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

impl<K, V> PartialOrd<OrdMap<K, V>> for OrdMap<K, V> where
    V: PartialOrd<V>,
    K: Ord, 

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

impl<K, V, S> PartialOrd<HashMap<K, V, S>> for HashMap<K, V, S> where
    V: PartialOrd<V> + Clone,
    S: BuildHasher,
    K: Hash + Eq + Clone + PartialOrd<K>, 

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

impl<A> PartialOrd<Vector<A>> for Vector<A> where
    A: Clone + PartialOrd<A>, 

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

impl<A> PartialOrd<OrdSet<A>> for OrdSet<A> where
    A: Ord, 

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

impl<A, S> PartialOrd<HashSet<A, S>> for HashSet<A, S> where
    A: Hash + Eq + Clone + PartialOrd<A>,
    S: BuildHasher + Default, 

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

impl<A, N> PartialOrd<Chunk<A, N>> for Chunk<A, N> where
    N: ChunkLength<A>,
    A: PartialOrd<A>, 

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

impl<A, T> PartialOrd<InlineArray<A, T>> for InlineArray<A, T> where
    A: PartialOrd<A>, 

pub fn partial_cmp(&self, other: &InlineArray<A, T>) -> 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 PartialOrd<Ready> for Ready

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

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

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

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

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

impl PartialOrd<Interest> for Interest

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

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

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

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

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

impl PartialOrd<Token> for Token

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

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

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

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

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

impl PartialOrd<ShutdownState> for ShutdownState

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

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

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

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

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

impl PartialOrd<ExtensionContext> for ExtensionContext

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

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

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

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

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

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

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

impl PartialOrd<Asn1TimeRef> for Asn1TimeRef

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

impl PartialOrd<SslOptions> for SslOptions

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

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

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

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

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

impl PartialOrd<CMSOptions> for CMSOptions

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

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

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

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

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

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

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

impl PartialOrd<BigNumRef> for BigNum

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

impl PartialOrd<SslVerifyMode> for SslVerifyMode

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

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

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

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

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

impl PartialOrd<X509VerifyFlags> for X509VerifyFlags

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

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

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

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

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

impl PartialOrd<OcspFlag> for OcspFlag

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

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

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

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

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

impl PartialOrd<SslMode> for SslMode

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

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

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

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

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

impl PartialOrd<X509CheckFlags> for X509CheckFlags

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

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

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

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

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

impl PartialOrd<BigNum> for BigNum

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

impl PartialOrd<BigNum> for BigNumRef

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

impl PartialOrd<Pkcs7Flags> for Pkcs7Flags

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

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

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

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

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

impl PartialOrd<Asn1Time> for Asn1Time

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

impl PartialOrd<SslSessionCacheMode> for SslSessionCacheMode

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

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

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

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

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

impl PartialOrd<Asn1TimeRef> for Asn1Time

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

impl PartialOrd<Asn1Time> for Asn1TimeRef

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

impl PartialOrd<BigNumRef> for BigNumRef

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

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

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

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

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

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

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

impl PartialOrd<BytesCodec> for BytesCodec

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

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

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

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

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

impl PartialOrd<LinesCodec> for LinesCodec

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

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

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

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

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

impl<A> PartialOrd<SmallString<A>> for SmallString<A> where
    A: Array<Item = u8>, 

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

impl PartialOrd<ParseProjectIdError> for ParseProjectIdError

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

impl PartialOrd<IpAddr> for IpAddress

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

impl PartialOrd<ProjectId> for ProjectId

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

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

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

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

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

impl PartialOrd<SessionStatus> for SessionStatus

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

impl PartialOrd<Level> for Level

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

impl PartialOrd<ThreadId> for ThreadId

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

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

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

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

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

impl PartialOrd<RegVal> for RegVal

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

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

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

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

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

impl PartialOrd<Addr> for Addr

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

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

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

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

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

impl PartialOrd<IpAddress> for IpAddress

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

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

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

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

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

impl PartialOrd<Scheme> for Scheme

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

impl PartialOrd<Url> for Url

URLs compare like their serialization.

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

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

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

pub fn lt(&self, other: &Host<S>) -> bool

pub fn le(&self, other: &Host<S>) -> bool

pub fn gt(&self, other: &Host<S>) -> bool

pub fn ge(&self, other: &Host<S>) -> bool

impl PartialOrd<CodeId> for CodeId

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

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

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

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

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

impl PartialOrd<DebugId> for DebugId

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

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

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

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

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

impl PartialOrd<HttpDate> for HttpDate

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

impl PartialOrd<HeaderValue> for [u8]

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

impl PartialOrd<[u8]> for HeaderValue

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

impl PartialOrd<HeaderValue> for String

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

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

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

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

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

impl PartialOrd<Authority> for String

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

impl PartialOrd<str> for PathAndQuery

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

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

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

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

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

impl PartialOrd<PathAndQuery> for PathAndQuery

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

impl PartialOrd<StatusCode> for StatusCode

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

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

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

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

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

impl PartialOrd<str> for HeaderValue

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

impl PartialOrd<str> for Authority

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

impl PartialOrd<HeaderValue> for HeaderValue

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

impl PartialOrd<String> for PathAndQuery

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

impl PartialOrd<HeaderValue> for str

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

impl PartialOrd<String> for HeaderValue

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

impl PartialOrd<PathAndQuery> for String

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

impl PartialOrd<String> for Authority

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

impl PartialOrd<Authority> for Authority

Case-insensitive ordering

Examples

let authority: Authority = "DEF.com".parse().unwrap();
assert!(authority < "ghi.com");
assert!(authority > "abc.com");

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

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

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

impl PartialOrd<PathAndQuery> for str

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

impl PartialOrd<Version> for Version

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

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

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

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

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

impl PartialOrd<Authority> for str

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

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

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

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

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

impl PartialOrd<str> for Bytes

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

impl PartialOrd<str> for BytesMut

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

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

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

impl PartialOrd<Bytes> for String

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

impl PartialOrd<String> for BytesMut

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

impl PartialOrd<Bytes> for str

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

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

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

impl PartialOrd<BytesMut> for BytesMut

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

impl<'_> PartialOrd<BytesMut> for &'_ [u8]

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

impl PartialOrd<[u8]> for BytesMut

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

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

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

impl<'_> PartialOrd<Bytes> for &'_ [u8]

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

impl PartialOrd<BytesMut> for str

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

impl<'_> PartialOrd<BytesMut> for &'_ str

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

impl PartialOrd<Bytes> for Bytes

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

impl PartialOrd<String> for Bytes

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

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

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

impl<'_> PartialOrd<Bytes> for &'_ str

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

impl PartialOrd<Bytes> for [u8]

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

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

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

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

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

impl PartialOrd<BytesMut> for [u8]

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

impl PartialOrd<BytesMut> for String

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

impl PartialOrd<[u8]> for Bytes

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

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

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

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

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

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

impl PartialOrd<Ready> for Ready

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

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

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

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

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

impl PartialOrd<PollOpt> for PollOpt

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

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

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

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

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

impl PartialOrd<Token> for Token

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

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

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

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

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

impl PartialOrd<Level> for Level

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

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

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

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

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

impl PartialOrd<LevelFilter> for LevelFilter

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

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

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

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

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

impl PartialOrd<LevelFilter> for Level

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

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

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

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

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

impl PartialOrd<Level> for LevelFilter

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

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

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

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

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

impl PartialOrd<Window> for u32

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

impl PartialOrd<LinesCodec> for LinesCodec

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

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

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

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

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

impl PartialOrd<BytesCodec> for BytesCodec

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<Mime> for Mime

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

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

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

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

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

impl PartialOrd<Ipv6AddrRange> for Ipv6AddrRange

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

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

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

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

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

impl PartialOrd<Ipv4Net> for Ipv4Net

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

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

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

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

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

impl PartialOrd<Ipv4AddrRange> for Ipv4AddrRange

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

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

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

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

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

impl PartialOrd<Ipv4Subnets> for Ipv4Subnets

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

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

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

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

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

impl PartialOrd<Ipv6Subnets> for Ipv6Subnets

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

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

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

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

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

impl PartialOrd<Ipv6Net> for Ipv6Net

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

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

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

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

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

impl PartialOrd<IpAddrRange> for IpAddrRange

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

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

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

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

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

impl PartialOrd<IpNet> for IpNet

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

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

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

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

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

impl PartialOrd<IpSubnets> for IpSubnets

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

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

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

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

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

impl PartialOrd<DwDsc> for DwDsc

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

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

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

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

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

impl PartialOrd<DwAccess> for DwAccess

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

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

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

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

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

impl PartialOrd<DwAte> for DwAte

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

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

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

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

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

impl<T> PartialOrd<ArangeEntry<T>> for ArangeEntry<T> where
    T: Ord + Copy, 

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

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

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

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

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

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

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

impl PartialOrd<Register> for Register

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<DwInl> for DwInl

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

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

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

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

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

impl PartialOrd<DwChildren> for DwChildren

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

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

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

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

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

impl PartialOrd<SectionId> for SectionId

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

impl PartialOrd<DwRle> for DwRle

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

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

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

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

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

impl PartialOrd<DwCc> for DwCc

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

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

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

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

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

impl PartialOrd<DwAddr> for DwAddr

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

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

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

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

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

impl PartialOrd<DwLle> for DwLle

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

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

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

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

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

impl PartialOrd<DwEhPe> for DwEhPe

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

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

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

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

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

impl PartialOrd<DwLnct> for DwLnct

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

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

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

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

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

impl PartialOrd<DwTag> for DwTag

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

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

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

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

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

impl PartialOrd<DwMacro> for DwMacro

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

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

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

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

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

impl PartialOrd<DwEnd> for DwEnd

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

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

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

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

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

impl PartialOrd<DwLne> for DwLne

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

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

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

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

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

impl PartialOrd<DwOp> for DwOp

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

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

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

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

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

impl PartialOrd<DwAt> for DwAt

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

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

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

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

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

impl PartialOrd<DwUt> for DwUt

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

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

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

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

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

impl PartialOrd<DwForm> for DwForm

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

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

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

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

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

impl PartialOrd<DwDs> for DwDs

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

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

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

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

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

impl PartialOrd<DwLang> for DwLang

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

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

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

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

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

impl PartialOrd<DwLns> for DwLns

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

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

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

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

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

impl PartialOrd<DwOrd> for DwOrd

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

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

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

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

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

impl PartialOrd<DwDefaulted> for DwDefaulted

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<DwCfa> for DwCfa

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

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

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

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

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

impl PartialOrd<DwId> for DwId

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

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

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

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

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

impl PartialOrd<DwIdx> for DwIdx

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

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

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

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

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

impl PartialOrd<DwVirtuality> for DwVirtuality

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

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<DwVis> for DwVis

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

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

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

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

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

impl PartialOrd<ColumnType> for ColumnType

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

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

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

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

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

impl<E> PartialOrd<I64Bytes<E>> for I64Bytes<E> where
    E: Endian + PartialOrd<E>, 

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

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

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

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

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

impl<E> PartialOrd<U64Bytes<E>> for U64Bytes<E> where
    E: Endian + PartialOrd<E>, 

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

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

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

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

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

impl<E> PartialOrd<U32Bytes<E>> for U32Bytes<E> where
    E: Endian + PartialOrd<E>, 

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

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

pub fn le(&self, other: &U32Bytes<E>) -> bool

pub fn gt(&self, other: &U32Bytes<E>) -> bool

pub fn ge(&self, other: &U32Bytes<E>) -> bool

impl<E> PartialOrd<U16Bytes<E>> for U16Bytes<E> where
    E: Endian + PartialOrd<E>, 

pub fn partial_cmp(&self, other: &U16Bytes<E>) -> Option<Ordering>

pub fn lt(&self, other: &U16Bytes<E>) -> bool

pub fn le(&self, other: &U16Bytes<E>) -> bool

pub fn gt(&self, other: &U16Bytes<E>) -> bool

pub fn ge(&self, other: &U16Bytes<E>) -> bool

impl<E> PartialOrd<I32Bytes<E>> for I32Bytes<E> where
    E: Endian + PartialOrd<E>, 

pub fn partial_cmp(&self, other: &I32Bytes<E>) -> Option<Ordering>

pub fn lt(&self, other: &I32Bytes<E>) -> bool

pub fn le(&self, other: &I32Bytes<E>) -> bool

pub fn gt(&self, other: &I32Bytes<E>) -> bool

pub fn ge(&self, other: &I32Bytes<E>) -> bool

impl<E> PartialOrd<I16Bytes<E>> for I16Bytes<E> where
    E: Endian + PartialOrd<E>, 

pub fn partial_cmp(&self, other: &I16Bytes<E>) -> Option<Ordering>

pub fn lt(&self, other: &I16Bytes<E>) -> bool

pub fn le(&self, other: &I16Bytes<E>) -> bool

pub fn gt(&self, other: &I16Bytes<E>) -> bool

pub fn ge(&self, other: &I16Bytes<E>) -> bool

impl PartialOrd<Window> for u32

pub fn partial_cmp(&self, other: &Window) -> Option<Ordering>

Loading content...

Implementors

impl PartialOrd<Level> for af_lib::log::Level

pub fn partial_cmp(&self, other: &Level) -> Option<Ordering>

pub fn lt(&self, other: &Level) -> bool

pub fn le(&self, other: &Level) -> bool

pub fn gt(&self, other: &Level) -> bool

pub fn ge(&self, other: &Level) -> bool

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<LevelFilter> for af_lib::log::Level

pub fn partial_cmp(&self, other: &LevelFilter) -> Option<Ordering>

pub fn lt(&self, other: &LevelFilter) -> bool

pub fn le(&self, other: &LevelFilter) -> bool

pub fn gt(&self, other: &LevelFilter) -> bool

pub fn ge(&self, other: &LevelFilter) -> bool

impl PartialOrd<Error> for Error

pub fn partial_cmp(&self, other: &Error) -> Option<Ordering>

impl PartialOrd<SharedString> for SharedString

pub fn partial_cmp(&self, other: &SharedString) -> Option<Ordering>

impl PartialOrd<Date> for af_lib::prelude::Date

pub fn partial_cmp(&self, other: &Date) -> Option<Ordering>

pub fn lt(&self, other: &Date) -> bool

pub fn le(&self, other: &Date) -> bool

pub fn gt(&self, other: &Date) -> bool

pub fn ge(&self, other: &Date) -> bool

impl PartialOrd<Duration> for af_lib::prelude::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<Time> for Time

pub fn partial_cmp(&self, other: &Time) -> Option<Ordering>

impl PartialOrd<Uuid> for af_lib::prelude::Uuid

pub fn partial_cmp(&self, other: &Uuid) -> Option<Ordering>

pub fn lt(&self, other: &Uuid) -> bool

pub fn le(&self, other: &Uuid) -> bool

pub fn gt(&self, other: &Uuid) -> bool

pub fn ge(&self, other: &Uuid) -> 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<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>

pub fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>

pub fn partial_cmp(&self, other: &&'b OsStr) -> 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<&'b Path> for Cow<'a, Path>

pub fn partial_cmp(&self, other: &&'b Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>

pub fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>

pub fn partial_cmp(&self, other: &OsString) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>

pub fn partial_cmp(&self, other: &Path) -> Option<Ordering>

impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>

pub fn partial_cmp(&self, other: &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<PathBuf> for Cow<'a, Path>

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, 

pub fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>

impl<L, R> PartialOrd<Either<L, R>> for Either<L, R> where
    L: PartialOrd<L>,
    R: PartialOrd<R>, 

pub fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>

pub fn lt(&self, other: &Either<L, R>) -> bool

pub fn le(&self, other: &Either<L, R>) -> bool

pub fn gt(&self, other: &Either<L, R>) -> bool

pub fn ge(&self, other: &Either<L, R>) -> 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<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<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<NonNull<T>> for NonNull<T> where
    T: ?Sized, 

pub fn partial_cmp(&self, other: &NonNull<T>) -> 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<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<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<PhantomData<T>> for PhantomData<T> where
    T: ?Sized, 

pub fn partial_cmp(&self, _other: &PhantomData<T>) -> 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));

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<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
    R: PartialOrd<R>,
    Y: PartialOrd<Y>, 

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...