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

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

[−] Expand description

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

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

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

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

Derivable

This trait can be used with #[derive]. When derived on structs, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct’s members. When derived on enums, variants are ordered by their top-to-bottom discriminant order.

How can I implement PartialOrd?

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

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

PartialOrd requires your type to be PartialEq.

Implementations of PartialEq, PartialOrd, and Ord must agree with each other. It’s easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

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

use std::cmp::Ordering;

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

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

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

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

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

use std::cmp::Ordering;

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

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

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

Examples

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

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

Required methods

#[must_use]

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

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

Examples

use std::cmp::Ordering;

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

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

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

When comparison is impossible:

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

Provided methods

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

Implementations on Foreign Types

impl PartialOrd<IpAddr> for Ipv4Addr

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<str> for OsString

[+] Show hidden undocumented items

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

impl PartialOrd<Instant> for Instant

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<CString> for CString

[+] Show hidden undocumented items

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

impl PartialOrd<Path> for Path

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<OsString> for OsString

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<OsStr> for OsStr

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<ErrorKind> for ErrorKind

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<IpAddr> for Ipv6Addr

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<Ipv6Addr> for Ipv6Addr

[+] Show hidden undocumented items

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

impl PartialOrd<SocketAddr> for SocketAddr

[+] Show hidden undocumented items

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

impl PartialOrd<SocketAddrV6> for SocketAddrV6

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<Ipv6Addr> for IpAddr

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<Ipv4Addr> for Ipv4Addr

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<CStr> for CStr

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<IpAddr> for IpAddr

[+] Show hidden undocumented items

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

impl PartialOrd<str> for OsStr

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<PathBuf> for PathBuf

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<SystemTime> for SystemTime

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<Ipv4Addr> for IpAddr

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<SocketAddrV4> for SocketAddrV4

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<isize> for isize

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<u32> for u32

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<CpuidResult> for CpuidResult

[+] Show hidden undocumented items

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

impl PartialOrd<PhantomPinned> for PhantomPinned

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<Duration> for Duration

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<i16> for i16

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<NonZeroI16> for NonZeroI16

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<i128> for i128

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<NonZeroIsize> for NonZeroIsize

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroU32> for NonZeroU32

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<bool> for bool

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroI8> for NonZeroI8

[+] Show hidden undocumented items

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

impl PartialOrd<()> for ()

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<TypeId> for TypeId

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroI128> for NonZeroI128

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroUsize> for NonZeroUsize

[+] Show hidden undocumented items

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

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

Implements comparison of vectors lexicographically.

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

[+] Show hidden undocumented items

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

impl PartialOrd<u128> for u128

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<f32> for f32

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<f64> for f64

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<NonZeroU16> for NonZeroU16

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<i8> for i8

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<char> for char

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroI32> for NonZeroI32

[+] Show hidden undocumented items

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

impl PartialOrd<i64> for i64

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<i32> for i32

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<usize> for usize

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<u16> for u16

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<NonZeroU8> for NonZeroU8

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<u64> for u64

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<NonZeroI64> for NonZeroI64

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroU64> for NonZeroU64

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl PartialOrd<NonZeroU128> for NonZeroU128

[+] Show hidden undocumented items

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

impl PartialOrd<!> for !

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

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

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

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

impl PartialOrd<u8> for u8

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

Partial comparison for two Arcs.

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

Examples

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

let five = Arc::new(5);

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

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

Less-than comparison for two Arcs.

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

Examples

use std::sync::Arc;

let five = Arc::new(5);

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

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

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

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

Examples

use std::sync::Arc;

let five = Arc::new(5);

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

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

Greater-than comparison for two Arcs.

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

Examples

use std::sync::Arc;

let five = Arc::new(5);

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

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

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

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

Examples

use std::sync::Arc;

let five = Arc::new(5);

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

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

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

Partial comparison for two Rcs.

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

Examples

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

let five = Rc::new(5);

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

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

Less-than comparison for two Rcs.

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

Examples

use std::rc::Rc;

let five = Rc::new(5);

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

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

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

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

Examples

use std::rc::Rc;

let five = Rc::new(5);

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

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

Greater-than comparison for two Rcs.

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

Examples

use std::rc::Rc;

let five = Rc::new(5);

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

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

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

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

Examples

use std::rc::Rc;

let five = Rc::new(5);

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

Implementors

impl PartialOrd<Ordering> for Ordering

[+] Show hidden undocumented items

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

impl PartialOrd<Infallible> for Infallible

[+] Show hidden undocumented items

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

impl PartialOrd<Error> for Error

[+] Show hidden undocumented items

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

impl PartialOrd<NoneError> for NoneError

[+] Show hidden undocumented items

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

impl PartialOrd<String> for String

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

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

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

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

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

Implements comparison of vectors, lexicographically.

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

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

[+] Show hidden undocumented items

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

impl<N: PartialOrd + Num + Clone + NumCast> PartialOrd<Deg<N>> for Deg<N>

impl<N: PartialOrd + Num + Clone + NumCast> PartialOrd<Rad<N>> for Rad<N>

impl PartialOrd<Error> for Error

impl PartialOrd<BigEndian> for BigEndian

impl PartialOrd<LittleEndian> for LittleEndian

impl PartialOrd<NaiveDate> for NaiveDate

impl PartialOrd<NaiveDateTime> for NaiveDateTime

impl PartialOrd<IsoWeek> for IsoWeek

impl PartialOrd<NaiveTime> for NaiveTime

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

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

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

impl PartialOrd<IdentString> for IdentString

impl PartialOrd<Compression> for Compression

impl PartialOrd<MatchingType> for MatchingType

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

impl PartialOrd<FixedBitSet> for FixedBitSet

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

impl PartialOrd<Index> for Index

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

impl PartialOrd<Register> for Register

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

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

impl<T: PartialOrd> PartialOrd<UnitSectionOffset<T>> for UnitSectionOffset<T>

impl PartialOrd<SectionId> for SectionId

impl PartialOrd<DwUt> for DwUt

impl PartialOrd<DwCfa> for DwCfa

impl PartialOrd<DwChildren> for DwChildren

impl PartialOrd<DwTag> for DwTag

impl PartialOrd<DwAt> for DwAt

impl PartialOrd<DwForm> for DwForm

impl PartialOrd<DwAte> for DwAte

impl PartialOrd<DwLle> for DwLle

impl PartialOrd<DwDs> for DwDs

impl PartialOrd<DwEnd> for DwEnd

impl PartialOrd<DwAccess> for DwAccess

impl PartialOrd<DwVis> for DwVis

impl PartialOrd<DwVirtuality> for DwVirtuality

impl PartialOrd<DwLang> for DwLang

impl PartialOrd<DwAddr> for DwAddr

impl PartialOrd<DwId> for DwId

impl PartialOrd<DwCc> for DwCc

impl PartialOrd<DwInl> for DwInl

impl PartialOrd<DwOrd> for DwOrd

impl PartialOrd<DwDsc> for DwDsc

impl PartialOrd<DwIdx> for DwIdx

impl PartialOrd<DwDefaulted> for DwDefaulted

impl PartialOrd<DwLns> for DwLns

impl PartialOrd<DwLne> for DwLne

impl PartialOrd<DwLnct> for DwLnct

impl PartialOrd<DwMacro> for DwMacro

impl PartialOrd<DwRle> for DwRle

impl PartialOrd<DwOp> for DwOp

impl PartialOrd<DwEhPe> for DwEhPe

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

impl PartialOrd<ColumnType> for ColumnType

impl<T: PartialOrd> PartialOrd<UnitOffset<T>> for UnitOffset<T>

impl PartialOrd<Action> for Action

impl PartialOrd<Key> for Key

impl PartialOrd<MouseButton> for MouseButton

impl PartialOrd<Error> for Error

impl PartialOrd<CursorMode> for CursorMode

impl PartialOrd<StandardCursor> for StandardCursor

impl PartialOrd<ContextReleaseBehavior> for ContextReleaseBehavior

impl PartialOrd<ContextCreationApi> for ContextCreationApi

impl PartialOrd<SwapInterval> for SwapInterval

impl PartialOrd<InitError> for InitError

impl PartialOrd<InitHint> for InitHint

impl PartialOrd<MonitorEvent> for MonitorEvent

impl PartialOrd<WindowHint> for WindowHint

impl PartialOrd<ClientApiHint> for ClientApiHint

impl PartialOrd<ContextRobustnessHint> for ContextRobustnessHint

impl PartialOrd<OpenGlProfileHint> for OpenGlProfileHint

impl PartialOrd<Modifiers> for Modifiers

impl PartialOrd<WindowEvent> for WindowEvent

impl PartialOrd<JoystickId> for JoystickId

impl PartialOrd<GamepadButton> for GamepadButton

impl PartialOrd<GamepadAxis> for GamepadAxis

impl PartialOrd<JoystickHats> for JoystickHats

impl PartialOrd<JoystickEvent> for JoystickEvent

impl PartialOrd<Rect> for Rect

impl PartialOrd<MapReadFlags> for MapReadFlags

impl PartialOrd<MapWriteFlags> for MapWriteFlags

impl PartialOrd<MapReadWriteFlags> for MapReadWriteFlags

impl PartialOrd<DebugSeverity> for DebugSeverity

impl PartialOrd<Property> for Property

impl PartialOrd<bf16> for bf16

impl PartialOrd<f16> for f16

impl PartialOrd<Direction> for Direction

impl PartialOrd<Language> for Language

impl PartialOrd<NormalForm> for NormalForm

impl PartialOrd<Delay> for Delay

impl PartialOrd<Level> for Level

impl PartialOrd<LevelFilter> for Level

impl PartialOrd<LevelFilter> for LevelFilter

impl PartialOrd<Level> for LevelFilter

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

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

impl PartialOrd<Vertex> for Vertex

impl PartialOrd<FloatDuration> for FloatDuration

impl PartialOrd<TimeStats> for TimeStats

impl PartialOrd<FloatInstant> for FloatInstant

impl<N, R: Dim, C: Dim, S> PartialOrd<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where     N: Scalar + PartialOrd,     S: Storage<N, R, C>,

impl<N: Scalar + PartialOrd, D: DimName> PartialOrd<Point<N, D>> for Point<N, D> where     DefaultAllocator: Allocator<N, D>,

impl PartialOrd<BroadPhaseProxyHandle> for BroadPhaseProxyHandle

impl PartialOrd<CollisionObjectUpdateFlags> for CollisionObjectUpdateFlags

impl PartialOrd<CollisionObjectSlabHandle> for CollisionObjectSlabHandle

impl PartialOrd<ContactId> for ContactId

impl PartialOrd<HeightFieldCellStatus> for HeightFieldCellStatus

impl<'a, N: PartialOrd, T> PartialOrd<RefWithCost<'a, N, T>> for RefWithCost<'a, N, T>

impl<T: PartialOrd> PartialOrd<SortedPair<T>> for SortedPair<T>

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

impl PartialOrd<U128> for U128

impl PartialOrd<U160> for U160

impl PartialOrd<U224> for U224

impl PartialOrd<U256> for U256

impl PartialOrd<U384> for U384

impl PartialOrd<U512> for U512

impl PartialOrd<U520> for U520

impl PartialOrd<U1024> for U1024

impl PartialOrd<U2048> for U2048

impl PartialOrd<U4096> for U4096

impl<E: PartialOrd + Endian> PartialOrd<U16Bytes<E>> for U16Bytes<E>

impl<E: PartialOrd + Endian> PartialOrd<U32Bytes<E>> for U32Bytes<E>

impl<E: PartialOrd + Endian> PartialOrd<U64Bytes<E>> for U64Bytes<E>

impl<E: PartialOrd + Endian> PartialOrd<I16Bytes<E>> for I16Bytes<E>

impl<E: PartialOrd + Endian> PartialOrd<I32Bytes<E>> for I32Bytes<E>

impl<E: PartialOrd + Endian> PartialOrd<I64Bytes<E>> for I64Bytes<E>

impl PartialOrd<Time> for Time

impl<Ix: PartialOrd> PartialOrd<NodeIndex<Ix>> for NodeIndex<Ix>

impl<Ix: PartialOrd> PartialOrd<EdgeIndex<Ix>> for EdgeIndex<Ix>

impl<'b, T> PartialOrd<Ptr<'b, T>> for Ptr<'b, T>

impl PartialOrd<Direction> for Direction

impl PartialOrd<Transformations> for Transformations

impl PartialOrd<Ident> for Ident

impl PartialOrd<Span> for Span

impl PartialOrd<Position> for Position

impl PartialOrd<Literal> for Literal

impl PartialOrd<ClassUnicodeRange> for ClassUnicodeRange

impl PartialOrd<ClassBytesRange> for ClassBytesRange

impl PartialOrd<Utf8Sequence> for Utf8Sequence

impl PartialOrd<Utf8Range> for Utf8Range

impl PartialOrd<RootMotionRemove> for RootMotionRemove

impl PartialOrd<BoxFlags> for BoxFlags

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

impl PartialOrd<TextureRef> for TextureRef

impl PartialOrd<CubemapRef> for CubemapRef

impl PartialOrd<SamplerRef> for SamplerRef

impl PartialOrd<TextureSampler> for TextureSampler

impl PartialOrd<CubemapSampler> for CubemapSampler

impl PartialOrd<TextureCreationFlags> for TextureCreationFlags

impl PartialOrd<MaterialRef> for MaterialRef

impl PartialOrd<MaterialMultiRef> for MaterialMultiRef

impl PartialOrd<ShadowMaterialRef> for ShadowMaterialRef

impl PartialOrd<Face> for Face

impl PartialOrd<BloomBlend> for BloomBlend

impl PartialOrd<TonemapTy> for TonemapTy

impl PartialOrd<SourcePath> for SourcePath

impl PartialOrd<UBOBindingPoints> for UBOBindingPoints

impl PartialOrd<ProgramRef> for ProgramRef

impl PartialOrd<ShadowMapRef> for ShadowMapRef

impl PartialOrd<GpuGeometryRef> for GpuGeometryRef

impl PartialOrd<GpuDebugGeometryRef> for GpuDebugGeometryRef

impl PartialOrd<GeomToGpuGeomRef> for GeomToGpuGeomRef

impl PartialOrd<VaoId> for VaoId

impl PartialOrd<BoneFlags> for BoneFlags

impl PartialOrd<GeometryRef> for GeometryRef

impl PartialOrd<NonNan> for NonNan

impl PartialOrd<Resolution> for Resolution

impl<E> PartialOrd<EnumSet<E>> for EnumSet<E>

impl PartialOrd<KeyModifiers> for KeyModifiers

impl PartialOrd<LibraryId> for LibraryId

impl PartialOrd<ObjectId> for ObjectId

impl PartialOrd<Flags> for Flags

impl PartialOrd<Flags> for Flags

impl PartialOrd<DriverTargetFlags> for DriverTargetFlags

impl PartialOrd<DriverVarFlag> for DriverVarFlag

impl PartialOrd<ArmatureDeformFlag> for ArmatureDeformFlag

impl PartialOrd<Flag> for Flag

impl PartialOrd<Flags> for Flags

impl PartialOrd<BlockFlags> for BlockFlags

impl PartialOrd<Entity> for Entity

impl PartialOrd<Identifier> for Identifier

impl PartialOrd<SemVerError> for SemVerError

impl PartialOrd<Version> for Version

impl PartialOrd<VersionReq> for VersionReq

impl PartialOrd<KeyData> for KeyData

impl PartialOrd<DefaultKey> for DefaultKey

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

impl PartialOrd<Lifetime> for Lifetime

impl PartialOrd<Duration> for Duration

impl PartialOrd<Timespec> for Timespec

impl PartialOrd<SteadyTime> for SteadyTime

impl PartialOrd<Tm> for Tm

impl<T: PartialOrd> PartialOrd<Spanned<T>> for Spanned<T>

impl PartialOrd<B0> for B0

impl PartialOrd<B1> for B1

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

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

impl PartialOrd<Z0> for Z0

impl PartialOrd<UTerm> for UTerm

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

impl PartialOrd<ATerm> for ATerm

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

impl PartialOrd<Greater> for Greater

impl PartialOrd<Less> for Less

impl PartialOrd<Equal> for Equal