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

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

    #[lang = "partial_ord"]
    pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
        #[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: &Person) -> Option<Ordering> {
            self.height.partial_cmp(&other.height)
        }
    }

    impl PartialEq for Person {
        fn eq(&self, other: &Person) -> 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

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

## Implementors

###

`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 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 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 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 for CpuidResult`

[src]

####

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

[src]

####

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

[src]

####

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

[src]

####

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

[src]

####

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

[src]

###

`impl PartialOrd 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 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 for Pinned`

[src]

####

`fn partial_cmp(&self, other: &Pinned) -> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b B> for &'a A where A: PartialOrd<B>,`

[src]

####

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

[src]

####

`fn lt(&self, other: &&'b B) -> bool`

[src]

####

`fn le(&self, other: &&'b B) -> bool`

[src]

####

`fn ge(&self, other: &&'b B) -> bool`

[src]

####

`fn gt(&self, other: &&'b B) -> bool`

[src]

###

`impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b mut B> for &'a mut A where A: PartialOrd<B>,`

[src]

####

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

[src]

####

`fn lt(&self, other: &&'b mut B) -> bool`

[src]

####

`fn le(&self, other: &&'b mut B) -> bool`

[src]

####

`fn ge(&self, other: &&'b mut B) -> bool`

[src]

####

`fn gt(&self, other: &&'b mut B) -> bool`

[src]

###

`impl<A> PartialOrd for (A,) where A: PartialOrd + PartialEq + ?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 + PartialEq, B> PartialOrd for (A, B) where B: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C> PartialOrd for (A, B, C) where C: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D> PartialOrd for (A, B, C, D) where D: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E> PartialOrd for (A, B, C, D, E) where E: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F> PartialOrd for (A, B, C, D, E, F) where F: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G> PartialOrd for (A, B, C, D, E, F, G) where G: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H> PartialOrd for (A, B, C, D, E, F, G, H) where H: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I> PartialOrd for (A, B, C, D, E, F, G, H, I) where I: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J> PartialOrd for (A, B, C, D, E, F, G, H, I, J) where J: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K> PartialOrd for (A, B, C, D, E, F, G, H, I, J, K) where K: PartialOrd + PartialEq + ?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: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K: PartialOrd + PartialEq, L> PartialOrd for (A, B, C, D, E, F, G, H, I, J, K, L) where L: PartialOrd + PartialEq + ?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<Ret> PartialOrd for extern "C" fn() -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret> PartialOrd for fn() -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret> PartialOrd for unsafe extern "C" fn() -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A> PartialOrd for extern "C" fn(_: A) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A> PartialOrd for extern "C" fn(_: A, ...) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A> PartialOrd for fn(_: A) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A> PartialOrd for unsafe extern "C" fn(_: A) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A> PartialOrd for unsafe extern "C" fn(_: A, ...) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A> PartialOrd for unsafe fn(_: A) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B> PartialOrd for extern "C" fn(_: A, _: B) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B> PartialOrd for fn(_: A, _: B) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B> PartialOrd for unsafe extern "C" fn(_: A, _: B) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B> PartialOrd for unsafe fn(_: A, _: B) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C> PartialOrd for extern "C" fn(_: A, _: B, _: C) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C> PartialOrd for fn(_: A, _: B, _: C) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C> PartialOrd for unsafe fn(_: A, _: B, _: C) -> Ret`

[src]

####

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

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D> PartialOrd for fn(_: A, _: B, _: C, _: D) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E> PartialOrd for extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E> PartialOrd for fn(_: A, _: B, _: C, _: D, _: E) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F> PartialOrd for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F> PartialOrd for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F> PartialOrd for fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G> PartialOrd for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G> PartialOrd for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G> PartialOrd for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H> PartialOrd for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H> PartialOrd for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret`

[src]

####

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

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I> PartialOrd for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret`

[src]

####

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

[src]

####

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

[src]

####

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

[src]

####

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

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret`

[src]

####

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

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`

[src]

####

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

[src]

####

`fn partial_cmp(&self, other: &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<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret`

[src]

####

`fn partial_cmp(&self, other: &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<T: PartialOrd + Copy> PartialOrd for Cell<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 + ?Sized> PartialOrd for ManuallyDrop<T>`

[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> PartialOrd for Option<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> PartialOrd for Poll<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> PartialOrd for Reverse<T>`

[src]

####

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

[src]

####

`fn lt(&self, other: &Self) -> bool`

[src]

####

`fn le(&self, other: &Self) -> bool`

[src]

####

`fn ge(&self, other: &Self) -> bool`

[src]

####

`fn gt(&self, other: &Self) -> bool`

[src]

###

`impl<T: PartialOrd> PartialOrd for Wrapping<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> PartialOrd for [T; 0]`

[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> PartialOrd for [T; 1]`

[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> PartialOrd for [T; 2]`

[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> PartialOrd for [T; 3]`

[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> PartialOrd for [T; 4]`

[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> PartialOrd for [T; 5]`

[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> PartialOrd for [T; 6]`

[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> PartialOrd for [T; 7]`

[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> PartialOrd for [T; 8]`

[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> PartialOrd for [T; 9]`

[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> PartialOrd for [T; 10]`

[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> PartialOrd for [T; 11]`

[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> PartialOrd for [T; 12]`

[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> PartialOrd for [T; 13]`

[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> PartialOrd for [T; 14]`

[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> PartialOrd for [T; 15]`

[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> PartialOrd for [T; 16]`

[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> PartialOrd for [T; 17]`

[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> PartialOrd for [T; 18]`

[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> PartialOrd for [T; 19]`

[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> PartialOrd for [T; 20]`

[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> PartialOrd for [T; 21]`

[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> PartialOrd for [T; 22]`

[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> PartialOrd for [T; 23]`

[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> PartialOrd for [T; 24]`

[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> PartialOrd for [T; 25]`

[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> PartialOrd for [T; 26]`

[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> PartialOrd for [T; 27]`

[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> PartialOrd for [T; 28]`

[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> PartialOrd for [T; 29]`

[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> PartialOrd for [T; 30]`

[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> PartialOrd for [T; 31]`

[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> PartialOrd for [T; 32]`

[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> PartialOrd for [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, E: PartialOrd> PartialOrd for Result<T, E>`

[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<T: ?Sized + PartialOrd> PartialOrd for RefCell<T>`

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

[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: ?Sized> PartialOrd for *mut T`

[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: ?Sized> PartialOrd for PhantomData<T>`

[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: ?Sized> PartialOrd for NonNull<T>`

[src]

####

`fn partial_cmp(&self, other: &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<Y: PartialOrd, R: PartialOrd> PartialOrd for GeneratorState<Y, R>`

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

# 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`)