std::cmp::PartialOrd - Rust
Description: API documentation for the Rust `PartialOrd` trait in crate `std`.
Keywords: rust, rustlang, rust-lang, PartialOrd

# 1.0.0[−][src]Trait std::cmp::PartialOrd

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

    #[must_use]
        fn lt(&self, other: &Rhs) -> bool { ... }
    #[must_use]
        fn le(&self, other: &Rhs) -> bool { ... }
    #[must_use]
        fn gt(&self, other: &Rhs) -> bool { ... }
    #[must_use]
        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`:

- antisymmetry: 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 `derive`d on structs, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct's members. When `derive`d on enums, variants are ordered by their top-to-bottom declaration 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: &Person) -> Option<Ordering> {
            Some(self.cmp(other))
        }
    }

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

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

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

# Examples

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

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

## Required methods

### `
#[must_use]
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));Run

When comparison is impossible:

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

Loading content...

## Provided methods

### `
#[must_use]
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);Run

### `
#[must_use]
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);Run

### `
#[must_use]
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);Run

### `
#[must_use]
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);Run

Loading content...

## Implementors

### `impl PartialOrd<Ordering> for Ordering`[src]

#### `fn partial_cmp(&self, other: &Ordering) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<Infallible> for Infallible`[src]

#### `fn partial_cmp(&self, _other: &Infallible) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<ErrorKind> for ErrorKind`[src]

#### `fn partial_cmp(&self, other: &ErrorKind) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<IpAddr> for IpAddr`[src]

#### `fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &IpAddr) -> bool`[src]

#### `fn le(&self, other: &IpAddr) -> bool`[src]

#### `fn gt(&self, other: &IpAddr) -> bool`[src]

#### `fn ge(&self, other: &IpAddr) -> bool`[src]

### `impl PartialOrd<IpAddr> for Ipv4Addr`[src]

#### `fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<IpAddr> for Ipv6Addr`[src]

#### `fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<bool> for bool`[src]

#### `fn partial_cmp(&self, other: &bool) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<char> for char`[src]

#### `fn partial_cmp(&self, other: &char) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &char) -> bool`[src]

#### `fn le(&self, other: &char) -> bool`[src]

#### `fn ge(&self, other: &char) -> bool`[src]

#### `fn gt(&self, other: &char) -> bool`[src]

### `impl PartialOrd<f32> for f32`[src]

#### `fn partial_cmp(&self, other: &f32) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &f32) -> bool`[src]

#### `fn le(&self, other: &f32) -> bool`[src]

#### `fn ge(&self, other: &f32) -> bool`[src]

#### `fn gt(&self, other: &f32) -> bool`[src]

### `impl PartialOrd<f64> for f64`[src]

#### `fn partial_cmp(&self, other: &f64) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &f64) -> bool`[src]

#### `fn le(&self, other: &f64) -> bool`[src]

#### `fn ge(&self, other: &f64) -> bool`[src]

#### `fn gt(&self, other: &f64) -> bool`[src]

### `impl PartialOrd<i128> for i128`[src]

#### `fn partial_cmp(&self, other: &i128) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &i128) -> bool`[src]

#### `fn le(&self, other: &i128) -> bool`[src]

#### `fn ge(&self, other: &i128) -> bool`[src]

#### `fn gt(&self, other: &i128) -> bool`[src]

### `impl PartialOrd<i16> for i16`[src]

#### `fn partial_cmp(&self, other: &i16) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &i16) -> bool`[src]

#### `fn le(&self, other: &i16) -> bool`[src]

#### `fn ge(&self, other: &i16) -> bool`[src]

#### `fn gt(&self, other: &i16) -> bool`[src]

### `impl PartialOrd<i32> for i32`[src]

#### `fn partial_cmp(&self, other: &i32) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &i32) -> bool`[src]

#### `fn le(&self, other: &i32) -> bool`[src]

#### `fn ge(&self, other: &i32) -> bool`[src]

#### `fn gt(&self, other: &i32) -> bool`[src]

### `impl PartialOrd<i64> for i64`[src]

#### `fn partial_cmp(&self, other: &i64) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &i64) -> bool`[src]

#### `fn le(&self, other: &i64) -> bool`[src]

#### `fn ge(&self, other: &i64) -> bool`[src]

#### `fn gt(&self, other: &i64) -> bool`[src]

### `impl PartialOrd<i8> for i8`[src]

#### `fn partial_cmp(&self, other: &i8) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &i8) -> bool`[src]

#### `fn le(&self, other: &i8) -> bool`[src]

#### `fn ge(&self, other: &i8) -> bool`[src]

#### `fn gt(&self, other: &i8) -> bool`[src]

### `impl PartialOrd<isize> for isize`[src]

#### `fn partial_cmp(&self, other: &isize) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &isize) -> bool`[src]

#### `fn le(&self, other: &isize) -> bool`[src]

#### `fn ge(&self, other: &isize) -> bool`[src]

#### `fn gt(&self, other: &isize) -> bool`[src]

### `impl PartialOrd<!> for !`[src]

#### `fn partial_cmp(&self, &!) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<str> for str`[src]

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.

#### `fn partial_cmp(&self, other: &str) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<str> for OsStr`[src]

#### `fn partial_cmp(&self, other: &str) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<str> for OsString`[src]

#### `fn partial_cmp(&self, other: &str) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<u128> for u128`[src]

#### `fn partial_cmp(&self, other: &u128) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &u128) -> bool`[src]

#### `fn le(&self, other: &u128) -> bool`[src]

#### `fn ge(&self, other: &u128) -> bool`[src]

#### `fn gt(&self, other: &u128) -> bool`[src]

### `impl PartialOrd<u16> for u16`[src]

#### `fn partial_cmp(&self, other: &u16) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &u16) -> bool`[src]

#### `fn le(&self, other: &u16) -> bool`[src]

#### `fn ge(&self, other: &u16) -> bool`[src]

#### `fn gt(&self, other: &u16) -> bool`[src]

### `impl PartialOrd<u32> for u32`[src]

#### `fn partial_cmp(&self, other: &u32) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &u32) -> bool`[src]

#### `fn le(&self, other: &u32) -> bool`[src]

#### `fn ge(&self, other: &u32) -> bool`[src]

#### `fn gt(&self, other: &u32) -> bool`[src]

### `impl PartialOrd<u64> for u64`[src]

#### `fn partial_cmp(&self, other: &u64) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &u64) -> bool`[src]

#### `fn le(&self, other: &u64) -> bool`[src]

#### `fn ge(&self, other: &u64) -> bool`[src]

#### `fn gt(&self, other: &u64) -> bool`[src]

### `impl PartialOrd<u8> for u8`[src]

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

#### `fn lt(&self, other: &u8) -> bool`[src]

#### `fn le(&self, other: &u8) -> bool`[src]

#### `fn ge(&self, other: &u8) -> bool`[src]

#### `fn gt(&self, other: &u8) -> bool`[src]

### `impl PartialOrd<()> for ()`[src]

#### `fn partial_cmp(&self, &()) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<usize> for usize`[src]

#### `fn partial_cmp(&self, other: &usize) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &usize) -> bool`[src]

#### `fn le(&self, other: &usize) -> bool`[src]

#### `fn ge(&self, other: &usize) -> bool`[src]

#### `fn gt(&self, other: &usize) -> bool`[src]

### `impl PartialOrd<TypeId> for TypeId`[src]

#### `fn partial_cmp(&self, other: &TypeId) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &TypeId) -> bool`[src]

#### `fn le(&self, other: &TypeId) -> bool`[src]

#### `fn gt(&self, other: &TypeId) -> bool`[src]

#### `fn ge(&self, other: &TypeId) -> bool`[src]

### `impl PartialOrd<UnicodeVersion> for UnicodeVersion`[src]

#### `fn partial_cmp(&self, other: &UnicodeVersion) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &UnicodeVersion) -> bool`[src]

#### `fn le(&self, other: &UnicodeVersion) -> bool`[src]

#### `fn gt(&self, other: &UnicodeVersion) -> bool`[src]

#### `fn ge(&self, other: &UnicodeVersion) -> bool`[src]

### `impl PartialOrd<CStr> for CStr`[src]

#### `fn partial_cmp(&self, other: &CStr) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<CString> for CString`[src]

#### `fn partial_cmp(&self, other: &CString) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &CString) -> bool`[src]

#### `fn le(&self, other: &CString) -> bool`[src]

#### `fn gt(&self, other: &CString) -> bool`[src]

#### `fn ge(&self, other: &CString) -> bool`[src]

### `impl PartialOrd<OsStr> for OsStr`[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &OsStr) -> bool`[src]

#### `fn le(&self, other: &OsStr) -> bool`[src]

#### `fn gt(&self, other: &OsStr) -> bool`[src]

#### `fn ge(&self, other: &OsStr) -> bool`[src]

### `impl PartialOrd<OsString> for OsString`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &OsString) -> bool`[src]

#### `fn le(&self, other: &OsString) -> bool`[src]

#### `fn gt(&self, other: &OsString) -> bool`[src]

#### `fn ge(&self, other: &OsString) -> bool`[src]

### `impl PartialOrd<Error> for Error`[src]

#### `fn partial_cmp(&self, other: &Error) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<PhantomPinned> for PhantomPinned`[src]

#### `fn partial_cmp(&self, other: &PhantomPinned) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<Ipv4Addr> for IpAddr`[src]

#### `fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<Ipv4Addr> for Ipv4Addr`[src]

#### `fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<Ipv6Addr> for IpAddr`[src]

#### `fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<Ipv6Addr> for Ipv6Addr`[src]

#### `fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<NonZeroI128> for NonZeroI128`[src]

#### `fn partial_cmp(&self, other: &NonZeroI128) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroI128) -> bool`[src]

#### `fn le(&self, other: &NonZeroI128) -> bool`[src]

#### `fn gt(&self, other: &NonZeroI128) -> bool`[src]

#### `fn ge(&self, other: &NonZeroI128) -> bool`[src]

### `impl PartialOrd<NonZeroI16> for NonZeroI16`[src]

#### `fn partial_cmp(&self, other: &NonZeroI16) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroI16) -> bool`[src]

#### `fn le(&self, other: &NonZeroI16) -> bool`[src]

#### `fn gt(&self, other: &NonZeroI16) -> bool`[src]

#### `fn ge(&self, other: &NonZeroI16) -> bool`[src]

### `impl PartialOrd<NonZeroI32> for NonZeroI32`[src]

#### `fn partial_cmp(&self, other: &NonZeroI32) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroI32) -> bool`[src]

#### `fn le(&self, other: &NonZeroI32) -> bool`[src]

#### `fn gt(&self, other: &NonZeroI32) -> bool`[src]

#### `fn ge(&self, other: &NonZeroI32) -> bool`[src]

### `impl PartialOrd<NonZeroI64> for NonZeroI64`[src]

#### `fn partial_cmp(&self, other: &NonZeroI64) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroI64) -> bool`[src]

#### `fn le(&self, other: &NonZeroI64) -> bool`[src]

#### `fn gt(&self, other: &NonZeroI64) -> bool`[src]

#### `fn ge(&self, other: &NonZeroI64) -> bool`[src]

### `impl PartialOrd<NonZeroI8> for NonZeroI8`[src]

#### `fn partial_cmp(&self, other: &NonZeroI8) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroI8) -> bool`[src]

#### `fn le(&self, other: &NonZeroI8) -> bool`[src]

#### `fn gt(&self, other: &NonZeroI8) -> bool`[src]

#### `fn ge(&self, other: &NonZeroI8) -> bool`[src]

### `impl PartialOrd<NonZeroIsize> for NonZeroIsize`[src]

#### `fn partial_cmp(&self, other: &NonZeroIsize) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroIsize) -> bool`[src]

#### `fn le(&self, other: &NonZeroIsize) -> bool`[src]

#### `fn gt(&self, other: &NonZeroIsize) -> bool`[src]

#### `fn ge(&self, other: &NonZeroIsize) -> bool`[src]

### `impl PartialOrd<NonZeroU128> for NonZeroU128`[src]

#### `fn partial_cmp(&self, other: &NonZeroU128) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroU128) -> bool`[src]

#### `fn le(&self, other: &NonZeroU128) -> bool`[src]

#### `fn gt(&self, other: &NonZeroU128) -> bool`[src]

#### `fn ge(&self, other: &NonZeroU128) -> bool`[src]

### `impl PartialOrd<NonZeroU16> for NonZeroU16`[src]

#### `fn partial_cmp(&self, other: &NonZeroU16) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroU16) -> bool`[src]

#### `fn le(&self, other: &NonZeroU16) -> bool`[src]

#### `fn gt(&self, other: &NonZeroU16) -> bool`[src]

#### `fn ge(&self, other: &NonZeroU16) -> bool`[src]

### `impl PartialOrd<NonZeroU32> for NonZeroU32`[src]

#### `fn partial_cmp(&self, other: &NonZeroU32) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroU32) -> bool`[src]

#### `fn le(&self, other: &NonZeroU32) -> bool`[src]

#### `fn gt(&self, other: &NonZeroU32) -> bool`[src]

#### `fn ge(&self, other: &NonZeroU32) -> bool`[src]

### `impl PartialOrd<NonZeroU64> for NonZeroU64`[src]

#### `fn partial_cmp(&self, other: &NonZeroU64) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroU64) -> bool`[src]

#### `fn le(&self, other: &NonZeroU64) -> bool`[src]

#### `fn gt(&self, other: &NonZeroU64) -> bool`[src]

#### `fn ge(&self, other: &NonZeroU64) -> bool`[src]

### `impl PartialOrd<NonZeroU8> for NonZeroU8`[src]

#### `fn partial_cmp(&self, other: &NonZeroU8) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroU8) -> bool`[src]

#### `fn le(&self, other: &NonZeroU8) -> bool`[src]

#### `fn gt(&self, other: &NonZeroU8) -> bool`[src]

#### `fn ge(&self, other: &NonZeroU8) -> bool`[src]

### `impl PartialOrd<NonZeroUsize> for NonZeroUsize`[src]

#### `fn partial_cmp(&self, other: &NonZeroUsize) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &NonZeroUsize) -> bool`[src]

#### `fn le(&self, other: &NonZeroUsize) -> bool`[src]

#### `fn gt(&self, other: &NonZeroUsize) -> bool`[src]

#### `fn ge(&self, other: &NonZeroUsize) -> bool`[src]

### `impl PartialOrd<NoneError> for NoneError`[src]

#### `fn partial_cmp(&self, other: &NoneError) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl PartialOrd<Path> for Path`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<PathBuf> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

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

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

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

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

### `impl PartialOrd<String> for String`[src]

#### `fn partial_cmp(&self, other: &String) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &String) -> bool`[src]

#### `fn le(&self, other: &String) -> bool`[src]

#### `fn gt(&self, other: &String) -> bool`[src]

#### `fn ge(&self, other: &String) -> bool`[src]

### `impl PartialOrd<Duration> for Duration`[src]

#### `fn partial_cmp(&self, other: &Duration) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Duration) -> bool`[src]

#### `fn le(&self, other: &Duration) -> bool`[src]

#### `fn gt(&self, other: &Duration) -> bool`[src]

#### `fn ge(&self, other: &Duration) -> bool`[src]

### `impl PartialOrd<Instant> for Instant`[src]

#### `fn partial_cmp(&self, other: &Instant) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Instant) -> bool`[src]

#### `fn le(&self, other: &Instant) -> bool`[src]

#### `fn gt(&self, other: &Instant) -> bool`[src]

#### `fn ge(&self, other: &Instant) -> bool`[src]

### `impl PartialOrd<SystemTime> for SystemTime`[src]

#### `fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &SystemTime) -> bool`[src]

#### `fn le(&self, other: &SystemTime) -> bool`[src]

#### `fn gt(&self, other: &SystemTime) -> bool`[src]

#### `fn ge(&self, other: &SystemTime) -> bool`[src]

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

#### `fn partial_cmp(&self, other: &&B) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &&B) -> bool`[src]

#### `fn le(&self, other: &&B) -> bool`[src]

#### `fn ge(&self, other: &&B) -> bool`[src]

#### `fn gt(&self, other: &&B) -> bool`[src]

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

#### `fn partial_cmp(&self, other: &&mut B) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &&mut B) -> bool`[src]

#### `fn le(&self, other: &&mut B) -> bool`[src]

#### `fn ge(&self, other: &&mut B) -> bool`[src]

#### `fn gt(&self, other: &&mut B) -> bool`[src]

### `impl<'a> PartialOrd<Component<'a>> for Component<'a>`[src]

#### `fn partial_cmp(&self, other: &Component<'a>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Component<'a>) -> bool`[src]

#### `fn le(&self, other: &Component<'a>) -> bool`[src]

#### `fn gt(&self, other: &Component<'a>) -> bool`[src]

#### `fn ge(&self, other: &Component<'a>) -> bool`[src]

### `impl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>`[src]

#### `fn partial_cmp(&self, other: &Prefix<'a>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Prefix<'a>) -> bool`[src]

#### `fn le(&self, other: &Prefix<'a>) -> bool`[src]

#### `fn gt(&self, other: &Prefix<'a>) -> bool`[src]

#### `fn ge(&self, other: &Prefix<'a>) -> bool`[src]

### `impl<'a> PartialOrd<Components<'a>> for Components<'a>`[src]

#### `fn partial_cmp(&self, other: &Components<'a>) -> Option<Ordering>`[src]

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

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

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

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

### `impl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>`[src]

#### `fn partial_cmp(&self, other: &PrefixComponent<'a>) -> Option<Ordering>`[src]

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

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

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

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

### `impl<'a, 'b> PartialOrd<&'a OsStr> for OsString`[src]

#### `fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'a OsStr> for Path`[src]

#### `fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>`[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'a Path> for OsStr`[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'a Path> for OsString`[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'a Path> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>`[src]

#### `fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>`[src]

#### `fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>`[src]

#### `fn partial_cmp(&self, other: &&'b Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, OsStr>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &Cow<'a, Path>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path`[src]

#### `fn partial_cmp(&self, other: &Cow<'b, OsStr>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsStr> for &'a Path`[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>`[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>`[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsStr> for OsString`[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsStr> for Path`[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsStr> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsString> for &'a OsStr`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsString> for &'a Path`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsString> for OsStr`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsString> for Path`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<OsString> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &OsString) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Path> for &'a OsStr`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Path> for OsStr`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Path> for OsString`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<Path> for PathBuf`[src]

#### `fn partial_cmp(&self, other: &Path) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<PathBuf> for &'a Path`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<PathBuf> for OsStr`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<PathBuf> for OsString`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<'a, 'b> PartialOrd<PathBuf> for Path`[src]

#### `fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>`[src]

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

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

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

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

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

#### `fn partial_cmp(&self, other: &(A,)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A,)) -> bool`[src]

#### `fn le(&self, other: &(A,)) -> bool`[src]

#### `fn ge(&self, other: &(A,)) -> bool`[src]

#### `fn gt(&self, other: &(A,)) -> bool`[src]

### `impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
A: PartialOrd<A>,` [src]

#### `fn partial_cmp(&self, other: &VecDeque<A>) -> Option<Ordering>`[src]

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

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

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

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

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

#### `fn partial_cmp(&self, other: &(A, B)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B)) -> bool`[src]

#### `fn le(&self, other: &(A, B)) -> bool`[src]

#### `fn ge(&self, other: &(A, B)) -> bool`[src]

#### `fn gt(&self, other: &(A, B)) -> bool`[src]

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

#### `fn partial_cmp(&self, other: &(A, B, C)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B, C)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C)) -> bool`[src]

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

#### `fn partial_cmp(&self, other: &(A, B, C, D)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B, C, D)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D)) -> bool`[src]

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

#### `fn partial_cmp(&self, other: &(A, B, C, D, E)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B, C, D, E)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D, E)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D, E)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D, E)) -> bool`[src]

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

#### `fn partial_cmp(&self, other: &(A, B, C, D, E, F)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B, C, D, E, F)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D, E, F)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D, E, F)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D, E, F)) -> bool`[src]

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

#### `fn partial_cmp(&self, other: &(A, B, C, D, E, F, G)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B, C, D, E, F, G)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool`[src]

### `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
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H> + ?Sized,` [src]

#### `fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool`[src]

### `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
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I> + ?Sized,` [src]

#### `fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool`[src]

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

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

#### `fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool`[src]

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

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

#### `fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`[src]

#### `fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`[src]

#### `fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`[src]

#### `fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool`[src]

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

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

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

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

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

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

### `impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialOrd<K>,
V: PartialOrd<V>,` [src]

#### `fn partial_cmp(&self, other: &BTreeMap<K, V>) -> Option<Ordering>`[src]

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

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

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

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

### `impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
P: PartialOrd<Q>,` [src]

#### `fn partial_cmp(&self, other: &Pin<Q>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Pin<Q>) -> bool`[src]

#### `fn le(&self, other: &Pin<Q>) -> bool`[src]

#### `fn gt(&self, other: &Pin<Q>) -> bool`[src]

#### `fn ge(&self, other: &Pin<Q>) -> bool`[src]

### `impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret`[src]

#### `fn partial_cmp(&self, other: &fn() -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`[src]

#### `fn partial_cmp(&self, other: &extern "C" fn() -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret`[src]

#### `fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret`[src]

#### `fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &extern "C" fn(A) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A> PartialOrd<extern "C" fn(A, VaList) -> Ret> for extern "C" fn(A, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`[src]

#### `fn partial_cmp(&self, other: &unsafe fn(A) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, VaList) -> Ret> for unsafe extern "C" fn(A, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret`[src]

#### `fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, VaList) -> Ret> for extern "C" fn(A, B, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, VaList) -> Ret> for unsafe extern "C" fn(A, B, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &fn(A, B, C) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, VaList) -> Ret> for extern "C" fn(A, B, C, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, VaList) -> Ret> for unsafe extern "C" fn(A, B, C, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, VaList) -> Ret> for extern "C" fn(A, B, C, D, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

#### `fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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, VaList) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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, VaList) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaList) -> Ret`[src]

#### `fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaList) -> Ret
) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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, VaList) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaList) -> Ret`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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, VaList) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaList) -> Ret`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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, VaList) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaList) -> Ret`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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, VaList) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaList) -> Ret`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `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, VaList) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaList) -> Ret`[src]

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

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<T> PartialOrd<Option<T>> for Option<T> where
T: PartialOrd<T>,` [src]

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

#### `fn lt(&self, other: &Option<T>) -> bool`[src]

#### `fn le(&self, other: &Option<T>) -> bool`[src]

#### `fn gt(&self, other: &Option<T>) -> bool`[src]

#### `fn ge(&self, other: &Option<T>) -> bool`[src]

### `impl<T> PartialOrd<Poll<T>> for Poll<T> where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &Poll<T>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Poll<T>) -> bool`[src]

#### `fn le(&self, other: &Poll<T>) -> bool`[src]

#### `fn gt(&self, other: &Poll<T>) -> bool`[src]

#### `fn ge(&self, other: &Poll<T>) -> bool`[src]

### `impl<T> PartialOrd<[T; 0]> for [T; 0] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 0]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 0]) -> bool`[src]

#### `fn le(&self, other: &[T; 0]) -> bool`[src]

#### `fn ge(&self, other: &[T; 0]) -> bool`[src]

#### `fn gt(&self, other: &[T; 0]) -> bool`[src]

### `impl<T> PartialOrd<[T; 10]> for [T; 10] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 10]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 10]) -> bool`[src]

#### `fn le(&self, other: &[T; 10]) -> bool`[src]

#### `fn ge(&self, other: &[T; 10]) -> bool`[src]

#### `fn gt(&self, other: &[T; 10]) -> bool`[src]

### `impl<T> PartialOrd<[T; 11]> for [T; 11] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 11]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 11]) -> bool`[src]

#### `fn le(&self, other: &[T; 11]) -> bool`[src]

#### `fn ge(&self, other: &[T; 11]) -> bool`[src]

#### `fn gt(&self, other: &[T; 11]) -> bool`[src]

### `impl<T> PartialOrd<[T; 12]> for [T; 12] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 12]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 12]) -> bool`[src]

#### `fn le(&self, other: &[T; 12]) -> bool`[src]

#### `fn ge(&self, other: &[T; 12]) -> bool`[src]

#### `fn gt(&self, other: &[T; 12]) -> bool`[src]

### `impl<T> PartialOrd<[T; 13]> for [T; 13] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 13]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 13]) -> bool`[src]

#### `fn le(&self, other: &[T; 13]) -> bool`[src]

#### `fn ge(&self, other: &[T; 13]) -> bool`[src]

#### `fn gt(&self, other: &[T; 13]) -> bool`[src]

### `impl<T> PartialOrd<[T; 14]> for [T; 14] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 14]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 14]) -> bool`[src]

#### `fn le(&self, other: &[T; 14]) -> bool`[src]

#### `fn ge(&self, other: &[T; 14]) -> bool`[src]

#### `fn gt(&self, other: &[T; 14]) -> bool`[src]

### `impl<T> PartialOrd<[T; 15]> for [T; 15] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 15]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 15]) -> bool`[src]

#### `fn le(&self, other: &[T; 15]) -> bool`[src]

#### `fn ge(&self, other: &[T; 15]) -> bool`[src]

#### `fn gt(&self, other: &[T; 15]) -> bool`[src]

### `impl<T> PartialOrd<[T; 16]> for [T; 16] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 16]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 16]) -> bool`[src]

#### `fn le(&self, other: &[T; 16]) -> bool`[src]

#### `fn ge(&self, other: &[T; 16]) -> bool`[src]

#### `fn gt(&self, other: &[T; 16]) -> bool`[src]

### `impl<T> PartialOrd<[T; 17]> for [T; 17] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 17]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 17]) -> bool`[src]

#### `fn le(&self, other: &[T; 17]) -> bool`[src]

#### `fn ge(&self, other: &[T; 17]) -> bool`[src]

#### `fn gt(&self, other: &[T; 17]) -> bool`[src]

### `impl<T> PartialOrd<[T; 18]> for [T; 18] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 18]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 18]) -> bool`[src]

#### `fn le(&self, other: &[T; 18]) -> bool`[src]

#### `fn ge(&self, other: &[T; 18]) -> bool`[src]

#### `fn gt(&self, other: &[T; 18]) -> bool`[src]

### `impl<T> PartialOrd<[T; 19]> for [T; 19] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 19]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 19]) -> bool`[src]

#### `fn le(&self, other: &[T; 19]) -> bool`[src]

#### `fn ge(&self, other: &[T; 19]) -> bool`[src]

#### `fn gt(&self, other: &[T; 19]) -> bool`[src]

### `impl<T> PartialOrd<[T; 1]> for [T; 1] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 1]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 1]) -> bool`[src]

#### `fn le(&self, other: &[T; 1]) -> bool`[src]

#### `fn ge(&self, other: &[T; 1]) -> bool`[src]

#### `fn gt(&self, other: &[T; 1]) -> bool`[src]

### `impl<T> PartialOrd<[T; 20]> for [T; 20] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 20]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 20]) -> bool`[src]

#### `fn le(&self, other: &[T; 20]) -> bool`[src]

#### `fn ge(&self, other: &[T; 20]) -> bool`[src]

#### `fn gt(&self, other: &[T; 20]) -> bool`[src]

### `impl<T> PartialOrd<[T; 21]> for [T; 21] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 21]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 21]) -> bool`[src]

#### `fn le(&self, other: &[T; 21]) -> bool`[src]

#### `fn ge(&self, other: &[T; 21]) -> bool`[src]

#### `fn gt(&self, other: &[T; 21]) -> bool`[src]

### `impl<T> PartialOrd<[T; 22]> for [T; 22] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 22]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 22]) -> bool`[src]

#### `fn le(&self, other: &[T; 22]) -> bool`[src]

#### `fn ge(&self, other: &[T; 22]) -> bool`[src]

#### `fn gt(&self, other: &[T; 22]) -> bool`[src]

### `impl<T> PartialOrd<[T; 23]> for [T; 23] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 23]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 23]) -> bool`[src]

#### `fn le(&self, other: &[T; 23]) -> bool`[src]

#### `fn ge(&self, other: &[T; 23]) -> bool`[src]

#### `fn gt(&self, other: &[T; 23]) -> bool`[src]

### `impl<T> PartialOrd<[T; 24]> for [T; 24] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 24]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 24]) -> bool`[src]

#### `fn le(&self, other: &[T; 24]) -> bool`[src]

#### `fn ge(&self, other: &[T; 24]) -> bool`[src]

#### `fn gt(&self, other: &[T; 24]) -> bool`[src]

### `impl<T> PartialOrd<[T; 25]> for [T; 25] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 25]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 25]) -> bool`[src]

#### `fn le(&self, other: &[T; 25]) -> bool`[src]

#### `fn ge(&self, other: &[T; 25]) -> bool`[src]

#### `fn gt(&self, other: &[T; 25]) -> bool`[src]

### `impl<T> PartialOrd<[T; 26]> for [T; 26] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 26]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 26]) -> bool`[src]

#### `fn le(&self, other: &[T; 26]) -> bool`[src]

#### `fn ge(&self, other: &[T; 26]) -> bool`[src]

#### `fn gt(&self, other: &[T; 26]) -> bool`[src]

### `impl<T> PartialOrd<[T; 27]> for [T; 27] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 27]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 27]) -> bool`[src]

#### `fn le(&self, other: &[T; 27]) -> bool`[src]

#### `fn ge(&self, other: &[T; 27]) -> bool`[src]

#### `fn gt(&self, other: &[T; 27]) -> bool`[src]

### `impl<T> PartialOrd<[T; 28]> for [T; 28] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 28]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 28]) -> bool`[src]

#### `fn le(&self, other: &[T; 28]) -> bool`[src]

#### `fn ge(&self, other: &[T; 28]) -> bool`[src]

#### `fn gt(&self, other: &[T; 28]) -> bool`[src]

### `impl<T> PartialOrd<[T; 29]> for [T; 29] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 29]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 29]) -> bool`[src]

#### `fn le(&self, other: &[T; 29]) -> bool`[src]

#### `fn ge(&self, other: &[T; 29]) -> bool`[src]

#### `fn gt(&self, other: &[T; 29]) -> bool`[src]

### `impl<T> PartialOrd<[T; 2]> for [T; 2] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 2]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 2]) -> bool`[src]

#### `fn le(&self, other: &[T; 2]) -> bool`[src]

#### `fn ge(&self, other: &[T; 2]) -> bool`[src]

#### `fn gt(&self, other: &[T; 2]) -> bool`[src]

### `impl<T> PartialOrd<[T; 30]> for [T; 30] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 30]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 30]) -> bool`[src]

#### `fn le(&self, other: &[T; 30]) -> bool`[src]

#### `fn ge(&self, other: &[T; 30]) -> bool`[src]

#### `fn gt(&self, other: &[T; 30]) -> bool`[src]

### `impl<T> PartialOrd<[T; 31]> for [T; 31] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 31]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 31]) -> bool`[src]

#### `fn le(&self, other: &[T; 31]) -> bool`[src]

#### `fn ge(&self, other: &[T; 31]) -> bool`[src]

#### `fn gt(&self, other: &[T; 31]) -> bool`[src]

### `impl<T> PartialOrd<[T; 32]> for [T; 32] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 32]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 32]) -> bool`[src]

#### `fn le(&self, other: &[T; 32]) -> bool`[src]

#### `fn ge(&self, other: &[T; 32]) -> bool`[src]

#### `fn gt(&self, other: &[T; 32]) -> bool`[src]

### `impl<T> PartialOrd<[T; 3]> for [T; 3] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 3]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 3]) -> bool`[src]

#### `fn le(&self, other: &[T; 3]) -> bool`[src]

#### `fn ge(&self, other: &[T; 3]) -> bool`[src]

#### `fn gt(&self, other: &[T; 3]) -> bool`[src]

### `impl<T> PartialOrd<[T; 4]> for [T; 4] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 4]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 4]) -> bool`[src]

#### `fn le(&self, other: &[T; 4]) -> bool`[src]

#### `fn ge(&self, other: &[T; 4]) -> bool`[src]

#### `fn gt(&self, other: &[T; 4]) -> bool`[src]

### `impl<T> PartialOrd<[T; 5]> for [T; 5] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 5]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 5]) -> bool`[src]

#### `fn le(&self, other: &[T; 5]) -> bool`[src]

#### `fn ge(&self, other: &[T; 5]) -> bool`[src]

#### `fn gt(&self, other: &[T; 5]) -> bool`[src]

### `impl<T> PartialOrd<[T; 6]> for [T; 6] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 6]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 6]) -> bool`[src]

#### `fn le(&self, other: &[T; 6]) -> bool`[src]

#### `fn ge(&self, other: &[T; 6]) -> bool`[src]

#### `fn gt(&self, other: &[T; 6]) -> bool`[src]

### `impl<T> PartialOrd<[T; 7]> for [T; 7] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 7]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 7]) -> bool`[src]

#### `fn le(&self, other: &[T; 7]) -> bool`[src]

#### `fn ge(&self, other: &[T; 7]) -> bool`[src]

#### `fn gt(&self, other: &[T; 7]) -> bool`[src]

### `impl<T> PartialOrd<[T; 8]> for [T; 8] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 8]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 8]) -> bool`[src]

#### `fn le(&self, other: &[T; 8]) -> bool`[src]

#### `fn ge(&self, other: &[T; 8]) -> bool`[src]

#### `fn gt(&self, other: &[T; 8]) -> bool`[src]

### `impl<T> PartialOrd<[T; 9]> for [T; 9] where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &[T; 9]) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &[T; 9]) -> bool`[src]

#### `fn le(&self, other: &[T; 9]) -> bool`[src]

#### `fn ge(&self, other: &[T; 9]) -> bool`[src]

#### `fn gt(&self, other: &[T; 9]) -> bool`[src]

### `impl<T> PartialOrd<*const T> for *const T where
T: ?Sized,` [src]

#### `fn partial_cmp(&self, other: &*const T) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &*const T) -> bool`[src]

#### `fn le(&self, other: &*const T) -> bool`[src]

#### `fn gt(&self, other: &*const T) -> bool`[src]

#### `fn ge(&self, other: &*const T) -> bool`[src]

### `impl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,` [src]

#### `fn partial_cmp(&self, other: &*mut T) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &*mut T) -> bool`[src]

#### `fn le(&self, other: &*mut T) -> bool`[src]

#### `fn gt(&self, other: &*mut T) -> bool`[src]

#### `fn ge(&self, other: &*mut T) -> bool`[src]

### `impl<T> PartialOrd<[T]> for [T] where
T: PartialOrd<T>,` [src]

Implements comparison of vectors lexicographically.

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

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

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

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

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

### `impl<T> PartialOrd<Box<T>> for Box<T> where
T: PartialOrd<T> + ?Sized,` [src]

#### `fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Box<T>) -> bool`[src]

#### `fn le(&self, other: &Box<T>) -> bool`[src]

#### `fn ge(&self, other: &Box<T>) -> bool`[src]

#### `fn gt(&self, other: &Box<T>) -> bool`[src]

### `impl<T> PartialOrd<Cell<T>> for Cell<T> where
T: Copy + PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &Cell<T>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Cell<T>) -> bool`[src]

#### `fn le(&self, other: &Cell<T>) -> bool`[src]

#### `fn gt(&self, other: &Cell<T>) -> bool`[src]

#### `fn ge(&self, other: &Cell<T>) -> bool`[src]

### `impl<T> PartialOrd<RefCell<T>> for RefCell<T> where
T: PartialOrd<T> + ?Sized,` [src]

#### `fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>`[src]

# Panics

Panics if the value in either `RefCell` is currently borrowed.

#### `fn lt(&self, other: &RefCell<T>) -> bool`[src]

# Panics

Panics if the value in either `RefCell` is currently borrowed.

#### `fn le(&self, other: &RefCell<T>) -> bool`[src]

# Panics

Panics if the value in either `RefCell` is currently borrowed.

#### `fn gt(&self, other: &RefCell<T>) -> bool`[src]

# Panics

Panics if the value in either `RefCell` is currently borrowed.

#### `fn ge(&self, other: &RefCell<T>) -> bool`[src]

# Panics

Panics if the value in either `RefCell` is currently borrowed.

### `impl<T> PartialOrd<Reverse<T>> for Reverse<T> where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Reverse<T>) -> bool`[src]

#### `fn le(&self, other: &Reverse<T>) -> bool`[src]

#### `fn ge(&self, other: &Reverse<T>) -> bool`[src]

#### `fn gt(&self, other: &Reverse<T>) -> bool`[src]

### `impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &BTreeSet<T>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &BTreeSet<T>) -> bool`[src]

#### `fn le(&self, other: &BTreeSet<T>) -> bool`[src]

#### `fn gt(&self, other: &BTreeSet<T>) -> bool`[src]

#### `fn ge(&self, other: &BTreeSet<T>) -> bool`[src]

### `impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &LinkedList<T>) -> Option<Ordering>`[src]

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

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

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

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

### `impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
T: ?Sized,` [src]

#### `fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<Ordering>`[src]

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

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

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

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

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

#### `fn partial_cmp(&self, other: &ManuallyDrop<T>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &ManuallyDrop<T>) -> bool`[src]

#### `fn le(&self, other: &ManuallyDrop<T>) -> bool`[src]

#### `fn gt(&self, other: &ManuallyDrop<T>) -> bool`[src]

#### `fn ge(&self, other: &ManuallyDrop<T>) -> bool`[src]

### `impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &Wrapping<T>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Wrapping<T>) -> bool`[src]

#### `fn le(&self, other: &Wrapping<T>) -> bool`[src]

#### `fn gt(&self, other: &Wrapping<T>) -> bool`[src]

#### `fn ge(&self, other: &Wrapping<T>) -> bool`[src]

### `impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
T: ?Sized,` [src]

#### `fn partial_cmp(&self, other: &NonNull<T>) -> Option<Ordering>`[src]

#### `
#[must_use]
fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn le(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

#### `
#[must_use]
fn ge(&self, other: &Rhs) -> bool`1.0.0[src]

### `impl<T> PartialOrd<Rc<T>> for Rc<T> where
T: PartialOrd<T> + ?Sized,` [src]

#### `fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>`[src]

Partial comparison for two `Rc`s.

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

#### `fn lt(&self, other: &Rc<T>) -> bool`[src]

Less-than comparison for two `Rc`s.

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

#### `fn le(&self, other: &Rc<T>) -> bool`[src]

'Less than or equal to' comparison for two `Rc`s.

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

#### `fn gt(&self, other: &Rc<T>) -> bool`[src]

Greater-than comparison for two `Rc`s.

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

#### `fn ge(&self, other: &Rc<T>) -> bool`[src]

'Greater than or equal to' comparison for two `Rc`s.

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

### `impl<T> PartialOrd<Arc<T>> for Arc<T> where
T: PartialOrd<T> + ?Sized,` [src]

#### `fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>`[src]

Partial comparison for two `Arc`s.

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

#### `fn lt(&self, other: &Arc<T>) -> bool`[src]

Less-than comparison for two `Arc`s.

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

#### `fn le(&self, other: &Arc<T>) -> bool`[src]

'Less than or equal to' comparison for two `Arc`s.

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

#### `fn gt(&self, other: &Arc<T>) -> bool`[src]

Greater-than comparison for two `Arc`s.

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

#### `fn ge(&self, other: &Arc<T>) -> bool`[src]

'Greater than or equal to' comparison for two `Arc`s.

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

### `impl<T> PartialOrd<Vec<T>> for Vec<T> where
T: PartialOrd<T>,` [src]

Implements comparison of vectors, lexicographically.

#### `fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering>`[src]

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

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

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

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

### `impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
E: PartialOrd<E>,
T: PartialOrd<T>,` [src]

#### `fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &Result<T, E>) -> bool`[src]

#### `fn le(&self, other: &Result<T, E>) -> bool`[src]

#### `fn gt(&self, other: &Result<T, E>) -> bool`[src]

#### `fn ge(&self, other: &Result<T, E>) -> bool`[src]

### `impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
R: PartialOrd<R>,
Y: PartialOrd<Y>,` [src]

#### `fn partial_cmp(&self, other: &GeneratorState<Y, R>) -> Option<Ordering>`[src]

#### `fn lt(&self, other: &GeneratorState<Y, R>) -> bool`[src]

#### `fn le(&self, other: &GeneratorState<Y, R>) -> bool`[src]

#### `fn gt(&self, other: &GeneratorState<Y, R>) -> bool`[src]

#### `fn ge(&self, other: &GeneratorState<Y, R>) -> bool`[src]

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)