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

    pub trait PartialOrd<Rhs = Self>: PartialEq<Rhs> where
        Rhs: ?Sized, {
        fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;

        fn lt(&self, other: &Rhs) -> bool { ... }
        fn le(&self, other: &Rhs) -> bool { ... }
        fn gt(&self, other: &Rhs) -> bool { ... }
        fn ge(&self, other: &Rhs) -> bool { ... }
    }

Expand description

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

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

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

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

## Derivable

This trait can be used with `#[derive]`. When `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 discriminant order.

## How can I implement `PartialOrd`?

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

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

`PartialOrd` requires your type to be `PartialEq`.

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

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

    use std::cmp::Ordering;

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

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

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

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

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

[src]
`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 = f64::NAN.partial_cmp(&1.0);
    assert_eq!(result, None);

Run

## Provided methods

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

## Implementations on Foreign Types

1.27.0[src]
`impl PartialOrd<CpuidResult> for CpuidResult`
[src]
`pub fn partial_cmp(&self, other: &CpuidResult) -> Option<Ordering>`

## Implementors

1.34.0[src]
`impl PartialOrd<Infallible> for Infallible`
[src]
`impl PartialOrd<ErrorKind> for ErrorKind`
1.7.0[src]
`impl PartialOrd<IpAddr> for IpAddr`
1.16.0[src]
`impl PartialOrd<IpAddr> for Ipv4Addr`
1.16.0[src]
`impl PartialOrd<IpAddr> for Ipv6Addr`
[src]
`impl PartialOrd<SocketAddr> for SocketAddr`
[src]
`impl PartialOrd<Ordering> for Ordering`
[src]
`impl PartialOrd<bool> for bool`
[src]
`impl PartialOrd<char> for char`
[src]
`impl PartialOrd<f32> for f32`
[src]
`impl PartialOrd<f64> for f64`
[src]
`impl PartialOrd<i8> for i8`
[src]
`impl PartialOrd<i16> for i16`
[src]
`impl PartialOrd<i32> for i32`
[src]
`impl PartialOrd<i64> for i64`
[src]
`impl PartialOrd<i128> for i128`
[src]
`impl PartialOrd<isize> for isize`
[src]
`impl PartialOrd<!> for !`
[src]
`impl PartialOrd<str> for str`
[src]
`impl PartialOrd<str> for OsStr`
[src]
`impl PartialOrd<str> for OsString`
[src]
`impl PartialOrd<u8> for u8`
[src]
`impl PartialOrd<u16> for u16`
[src]
`impl PartialOrd<u32> for u32`
[src]
`impl PartialOrd<u64> for u64`
[src]
`impl PartialOrd<u128> for u128`
[src]
`impl PartialOrd<()> for ()`
[src]
`impl PartialOrd<usize> for usize`
[src]
`impl PartialOrd<TypeId> for TypeId`
[src]
`impl PartialOrd<CStr> for CStr`
[src]
`impl PartialOrd<CString> for CString`
[src]
`impl PartialOrd<OsStr> for OsStr`
[src]
`impl PartialOrd<OsString> for OsString`
[src]
`impl PartialOrd<Error> for Error`
1.33.0[src]
`impl PartialOrd<PhantomPinned> for PhantomPinned`
1.16.0[src]
`impl PartialOrd<Ipv4Addr> for IpAddr`
[src]
`impl PartialOrd<Ipv4Addr> for Ipv4Addr`
1.16.0[src]
`impl PartialOrd<Ipv6Addr> for IpAddr`
[src]
`impl PartialOrd<Ipv6Addr> for Ipv6Addr`
1.45.0[src]
`impl PartialOrd<SocketAddrV4> for SocketAddrV4`
1.45.0[src]
`impl PartialOrd<SocketAddrV6> for SocketAddrV6`
1.34.0[src]
`impl PartialOrd<NonZeroI8> for NonZeroI8`
1.34.0[src]
`impl PartialOrd<NonZeroI16> for NonZeroI16`
1.34.0[src]
`impl PartialOrd<NonZeroI32> for NonZeroI32`
1.34.0[src]
`impl PartialOrd<NonZeroI64> for NonZeroI64`
1.34.0[src]
`impl PartialOrd<NonZeroI128> for NonZeroI128`
1.34.0[src]
`impl PartialOrd<NonZeroIsize> for NonZeroIsize`
1.28.0[src]
`impl PartialOrd<NonZeroU8> for NonZeroU8`
1.28.0[src]
`impl PartialOrd<NonZeroU16> for NonZeroU16`
1.28.0[src]
`impl PartialOrd<NonZeroU32> for NonZeroU32`
1.28.0[src]
`impl PartialOrd<NonZeroU64> for NonZeroU64`
1.28.0[src]
`impl PartialOrd<NonZeroU128> for NonZeroU128`
1.28.0[src]
`impl PartialOrd<NonZeroUsize> for NonZeroUsize`
[src]
`impl PartialOrd<Path> for Path`
[src]
`impl PartialOrd<PathBuf> for PathBuf`
[src]
`impl PartialOrd<String> for String`
1.3.0[src]
`impl PartialOrd<Duration> for Duration`
1.8.0[src]
`impl PartialOrd<Instant> for Instant`
1.8.0[src]
`impl PartialOrd<SystemTime> for SystemTime`
[src]
`impl<'_, '_, A, B> PartialOrd<&'_ B> for &'_ A where
B: ?Sized,
A: PartialOrd<B> + ?Sized,`
[src]
`impl<'_, '_, A, B> PartialOrd<&'_ mut B> for &'_ mut A where
B: ?Sized,
A: PartialOrd<B> + ?Sized,`
[src]
`impl<'a> PartialOrd<Component<'a>> for Component<'a>`
[src]
`impl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>`
1.10.0[src]
`impl<'a> PartialOrd<Location<'a>> for Location<'a>`
[src]
`impl<'a> PartialOrd<Components<'a>> for Components<'a>`
[src]
`impl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'a OsStr> for OsString`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'a OsStr> for Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'a Path> for OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'a Path> for OsString`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'a Path> for PathBuf`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for PathBuf`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsStr> for &'a Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsStr> for OsString`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsStr> for Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsStr> for PathBuf`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsString> for &'a OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsString> for &'a Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsString> for OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsString> for Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<OsString> for PathBuf`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Path> for &'a OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Path> for OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Path> for OsString`
1.8.0[src]
`impl<'a, 'b> PartialOrd<Path> for PathBuf`
1.8.0[src]
`impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<PathBuf> for &'a Path`
1.8.0[src]
`impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>`
1.8.0[src]
`impl<'a, 'b> PartialOrd<PathBuf> for OsStr`
1.8.0[src]
`impl<'a, 'b> PartialOrd<PathBuf> for OsString`
1.8.0[src]
`impl<'a, 'b> PartialOrd<PathBuf> for Path`
[src]
`impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
B: PartialOrd<B> + ToOwned + ?Sized,`
[src]
`impl<A> PartialOrd<(A,)> for (A,) where
A: PartialOrd<A> + PartialEq<A> + ?Sized,`
[src]
`impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
A: PartialOrd<A>,`
[src]
`impl<A, B> PartialOrd<(A, B)> for (A, B) where
B: PartialOrd<B> + PartialEq<B> + ?Sized,
A: PartialOrd<A> + PartialEq<A>,`
[src]
`impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
C: PartialOrd<C> + PartialEq<C> + ?Sized,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,`
[src]
`impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
C: PartialOrd<C> + PartialEq<C>,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
D: PartialOrd<D> + PartialEq<D> + ?Sized,`
[src]
`impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
C: PartialOrd<C> + PartialEq<C>,
E: PartialOrd<E> + PartialEq<E> + ?Sized,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
D: PartialOrd<D> + PartialEq<D>,`
[src]
`impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
C: PartialOrd<C> + PartialEq<C>,
F: PartialOrd<F> + PartialEq<F> + ?Sized,
E: PartialOrd<E> + PartialEq<E>,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
D: PartialOrd<D> + PartialEq<D>,`
[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
C: PartialOrd<C> + PartialEq<C>,
F: PartialOrd<F> + PartialEq<F>,
E: PartialOrd<E> + PartialEq<E>,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
G: PartialOrd<G> + PartialEq<G> + ?Sized,
D: PartialOrd<D> + PartialEq<D>,`
[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
C: PartialOrd<C> + PartialEq<C>,
F: PartialOrd<F> + PartialEq<F>,
E: PartialOrd<E> + PartialEq<E>,
H: PartialOrd<H> + PartialEq<H> + ?Sized,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
G: PartialOrd<G> + PartialEq<G>,
D: PartialOrd<D> + PartialEq<D>,`
[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
C: PartialOrd<C> + PartialEq<C>,
F: PartialOrd<F> + PartialEq<F>,
I: PartialOrd<I> + PartialEq<I> + ?Sized,
E: PartialOrd<E> + PartialEq<E>,
H: PartialOrd<H> + PartialEq<H>,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
G: PartialOrd<G> + PartialEq<G>,
D: PartialOrd<D> + PartialEq<D>,`
[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
C: PartialOrd<C> + PartialEq<C>,
F: PartialOrd<F> + PartialEq<F>,
I: PartialOrd<I> + PartialEq<I>,
E: PartialOrd<E> + PartialEq<E>,
H: PartialOrd<H> + PartialEq<H>,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
J: PartialOrd<J> + PartialEq<J> + ?Sized,
G: PartialOrd<G> + PartialEq<G>,
D: PartialOrd<D> + PartialEq<D>,`
[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
C: PartialOrd<C> + PartialEq<C>,
F: PartialOrd<F> + PartialEq<F>,
K: PartialOrd<K> + PartialEq<K> + ?Sized,
I: PartialOrd<I> + PartialEq<I>,
E: PartialOrd<E> + PartialEq<E>,
H: PartialOrd<H> + PartialEq<H>,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
J: PartialOrd<J> + PartialEq<J>,
G: PartialOrd<G> + PartialEq<G>,
D: PartialOrd<D> + PartialEq<D>,`
[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
C: PartialOrd<C> + PartialEq<C>,
F: PartialOrd<F> + PartialEq<F>,
K: PartialOrd<K> + PartialEq<K>,
I: PartialOrd<I> + PartialEq<I>,
E: PartialOrd<E> + PartialEq<E>,
H: PartialOrd<H> + PartialEq<H>,
B: PartialOrd<B> + PartialEq<B>,
A: PartialOrd<A> + PartialEq<A>,
J: PartialOrd<J> + PartialEq<J>,
G: PartialOrd<G> + PartialEq<G>,
D: PartialOrd<D> + PartialEq<D>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,`
[src]
`impl<Dyn> PartialOrd<DynMetadata<Dyn>> for DynMetadata<Dyn> where
Dyn: ?Sized,`
[src]
`impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialOrd<K>,
V: PartialOrd<V>,`
1.41.0[src]
`impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
Q: Deref,
P: Deref,
<P as Deref>::Target: PartialOrd<<Q as Deref>::Target>,`
1.4.0[src]
`impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret`
1.4.0[src]
`impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`
1.4.0[src]
`impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret`
1.4.0[src]
`impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`
1.4.0[src]
`impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret`
1.4.0[src]
`impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`
1.4.0[src]
`impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret`
1.4.0[src]
`impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`
1.4.0[src]
`impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`
1.4.0[src]
`impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret`
1.4.0[src]
`impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`
1.4.0[src]
`impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`
1.4.0[src]
`impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`
1.4.0[src]
`impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret`
1.4.0[src]
`impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`
1.4.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`
1.4.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`
1.4.0[src]
`impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`
1.4.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`
1.4.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`
1.4.0[src]
`impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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`
1.4.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]
`impl<T> PartialOrd<Option<T>> for Option<T> where
T: PartialOrd<T>,`
1.36.0[src]
`impl<T> PartialOrd<Poll<T>> for Poll<T> where
T: PartialOrd<T>,`
[src]
`impl<T> PartialOrd<*const T> for *const T where
T: ?Sized,`
[src]
`impl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,`
[src]
`impl<T> PartialOrd<[T]> for [T] where
T: PartialOrd<T>,`
1.10.0[src]
`impl<T> PartialOrd<Cell<T>> for Cell<T> where
T: PartialOrd<T> + Copy,`
1.10.0[src]
`impl<T> PartialOrd<RefCell<T>> for RefCell<T> where
T: PartialOrd<T> + ?Sized,`
[src]
`impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
T: PartialOrd<T>,`
[src]
`impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,`
[src]
`impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
T: ?Sized,`
1.20.0[src]
`impl<T> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialOrd<T> + ?Sized,`
[src]
`impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,`
1.25.0[src]
`impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
T: ?Sized,`
[src]
`impl<T> PartialOrd<Rc<T>> for Rc<T> where
T: PartialOrd<T> + ?Sized,`
[src]
`impl<T> PartialOrd<Arc<T>> for Arc<T> where
T: PartialOrd<T> + ?Sized,`
1.19.0[src]
`impl<T> PartialOrd<Reverse<T>> for Reverse<T> where
T: PartialOrd<T>,`
[src]
`impl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
T: PartialOrd<T> + ?Sized,
A: Allocator,`
[src]
`impl<T, A> PartialOrd<Vec<T, A>> for Vec<T, A> where
T: PartialOrd<T>,
A: Allocator,`
[src]
`impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
T: PartialOrd<T>,
E: PartialOrd<E>,`
[src]
`impl<T, const N: usize> PartialOrd<[T; N]> for [T; N] where
T: PartialOrd<T>,`
[src]
`impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
R: PartialOrd<R>,
Y: PartialOrd<Y>,`