# Trait std::cmp::PartialOrd [−] [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 { ... }
}```

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

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

This trait can be used with `#[derive]`.

## Required Methods

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

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

# Examples

fn main() { 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)); }
```use std::cmp::Ordering;

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

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

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

When comparison is impossible:

fn main() { let result = std::f64::NAN.partial_cmp(&1.0); assert_eq!(result, None); }
```let result = std::f64::NAN.partial_cmp(&1.0);
assert_eq!(result, None);```

## Provided Methods

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

This method tests less than (for `self` and `other`) and is used by the `<` operator.

# Examples

fn main() { let result = 1.0 < 2.0; assert_eq!(result, true); let result = 2.0 < 1.0; assert_eq!(result, false); }
```let result = 1.0 < 2.0;
assert_eq!(result, true);

let result = 2.0 < 1.0;
assert_eq!(result, false);```

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

fn main() { let result = 1.0 <= 2.0; assert_eq!(result, true); let result = 2.0 <= 2.0; assert_eq!(result, true); }
```let result = 1.0 <= 2.0;
assert_eq!(result, true);

let result = 2.0 <= 2.0;
assert_eq!(result, true);```

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator.

# Examples

fn main() { let result = 1.0 > 2.0; assert_eq!(result, false); let result = 2.0 > 2.0; assert_eq!(result, false); }
```let result = 1.0 > 2.0;
assert_eq!(result, false);

let result = 2.0 > 2.0;
assert_eq!(result, false);```

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

fn main() { let result = 2.0 >= 1.0; assert_eq!(result, true); let result = 2.0 >= 2.0; assert_eq!(result, true); }
```let result = 2.0 >= 1.0;
assert_eq!(result, true);

let result = 2.0 >= 2.0;
assert_eq!(result, true);```

## Implementors

• `impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where T: PartialOrd<T>`
• `impl PartialOrd<Big32x40> for Big32x40`
• `impl PartialOrd<Big8x3> for Big8x3`
• `impl<T> PartialOrd<NonZero<T>> for NonZero<T> where T: Zeroable + PartialOrd<T>`
• `impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret`
• `impl<Ret> PartialOrd< extern "C" fn() -> Ret> for extern "C" fn() -> Ret`
• `impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret`
• `impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`
• `impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret`
• `impl<Ret, A> PartialOrd< extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`
• `impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`
• `impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`
• `impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret`
• `impl<Ret, A, B> PartialOrd< extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`
• `impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`
• `impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`
• `impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C> PartialOrd< extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`
• `impl<Ret, A, B, C, D> PartialOrd< extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret`
• `impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`
• `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`
• `impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `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`
• `impl<T> PartialOrd<*const T> for *const T where T: ?Sized`
• `impl<T> PartialOrd<*mut T> for *mut T where T: ?Sized`
• `impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where T: ?Sized`
• `impl PartialOrd<Ordering> for Ordering`
• `impl PartialOrd<()> for ()`
• `impl PartialOrd<bool> for bool`
• `impl PartialOrd<f32> for f32`
• `impl PartialOrd<f64> for f64`
• `impl PartialOrd<char> for char`
• `impl PartialOrd<usize> for usize`
• `impl PartialOrd<u8> for u8`
• `impl PartialOrd<u16> for u16`
• `impl PartialOrd<u32> for u32`
• `impl PartialOrd<u64> for u64`
• `impl PartialOrd<isize> for isize`
• `impl PartialOrd<i8> for i8`
• `impl PartialOrd<i16> for i16`
• `impl PartialOrd<i32> for i32`
• `impl PartialOrd<i64> for i64`
• `impl<'a, 'b, A, B> PartialOrd<&'b B> for &'a A where B: ?Sized, A: PartialOrd<B> + ?Sized`
• `impl<'a, 'b, A, B> PartialOrd<&'b mut B> for &'a mut A where B: ?Sized, A: PartialOrd<B> + ?Sized`
• `impl<T> PartialOrd<[T; 0]> for [T; 0] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 1]> for [T; 1] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 2]> for [T; 2] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 3]> for [T; 3] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 4]> for [T; 4] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 5]> for [T; 5] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 6]> for [T; 6] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 7]> for [T; 7] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 8]> for [T; 8] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 9]> for [T; 9] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 10]> for [T; 10] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 11]> for [T; 11] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 12]> for [T; 12] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 13]> for [T; 13] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 14]> for [T; 14] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 15]> for [T; 15] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 16]> for [T; 16] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 17]> for [T; 17] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 18]> for [T; 18] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 19]> for [T; 19] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 20]> for [T; 20] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 21]> for [T; 21] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 22]> for [T; 22] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 23]> for [T; 23] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 24]> for [T; 24] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 25]> for [T; 25] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 26]> for [T; 26] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 27]> for [T; 27] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 28]> for [T; 28] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 29]> for [T; 29] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 30]> for [T; 30] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 31]> for [T; 31] where T: PartialOrd<T>`
• `impl<T> PartialOrd<[T; 32]> for [T; 32] where T: PartialOrd<T>`
• `impl<T> PartialOrd<Option<T>> for Option<T> where T: PartialOrd<T>`
• `impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where T: PartialOrd<T>, E: PartialOrd<E>`
• `impl<T> PartialOrd<[T]> for [T] where T: PartialOrd<T>`
• `impl PartialOrd<str> for str`
• `impl<A> PartialOrd<(A,)> for (A,) where A: PartialEq<A> + PartialOrd<A>`
• `impl<A, B> PartialOrd<(A, B)> for (A, B) where B: PartialEq<B> + PartialOrd<B>, A: PartialEq<A> + PartialOrd<A>`
• `impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where C: PartialEq<C> + PartialOrd<C>, A: PartialEq<A> + PartialOrd<A>, B: PartialEq<B> + PartialOrd<B>`
• `impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where B: PartialEq<B> + PartialOrd<B>, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, A: PartialEq<A> + PartialOrd<A>`
• `impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where C: PartialEq<C> + PartialOrd<C>, A: PartialEq<A> + PartialOrd<A>, E: PartialEq<E> + PartialOrd<E>, B: PartialEq<B> + PartialOrd<B>, D: PartialEq<D> + PartialOrd<D>`
• `impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where C: PartialEq<C> + PartialOrd<C>, A: PartialEq<A> + PartialOrd<A>, E: PartialEq<E> + PartialOrd<E>, B: PartialEq<B> + PartialOrd<B>, F: PartialEq<F> + PartialOrd<F>, D: PartialEq<D> + PartialOrd<D>`
• `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 F: PartialEq<F> + PartialOrd<F>, C: PartialEq<C> + PartialOrd<C>, B: PartialEq<B> + PartialOrd<B>, D: PartialEq<D> + PartialOrd<D>, G: PartialEq<G> + PartialOrd<G>, E: PartialEq<E> + PartialOrd<E>, A: PartialEq<A> + PartialOrd<A>`
• `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 B: PartialEq<B> + PartialOrd<B>, C: PartialEq<C> + PartialOrd<C>, H: PartialEq<H> + PartialOrd<H>, G: PartialEq<G> + PartialOrd<G>, F: PartialEq<F> + PartialOrd<F>, D: PartialEq<D> + PartialOrd<D>, A: PartialEq<A> + PartialOrd<A>, E: PartialEq<E> + PartialOrd<E>`
• `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 E: PartialEq<E> + PartialOrd<E>, C: PartialEq<C> + PartialOrd<C>, I: PartialEq<I> + PartialOrd<I>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, D: PartialEq<D> + PartialOrd<D>, H: PartialEq<H> + PartialOrd<H>, B: PartialEq<B> + PartialOrd<B>, A: PartialEq<A> + PartialOrd<A>`
• `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 E: PartialEq<E> + PartialOrd<E>, J: PartialEq<J> + PartialOrd<J>, F: PartialEq<F> + PartialOrd<F>, A: PartialEq<A> + PartialOrd<A>, I: PartialEq<I> + PartialOrd<I>, H: PartialEq<H> + PartialOrd<H>, C: PartialEq<C> + PartialOrd<C>, B: PartialEq<B> + PartialOrd<B>, G: PartialEq<G> + PartialOrd<G>, D: PartialEq<D> + PartialOrd<D>`
• `impl<A, B, C, D, E, F, G, H, I, J, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where A: PartialEq<A> + PartialOrd<A>, H: PartialEq<H> + PartialOrd<H>, K: PartialEq<K> + PartialOrd<K>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, C: PartialEq<C> + PartialOrd<C>, I: PartialEq<I> + PartialOrd<I>, J: PartialEq<J> + PartialOrd<J>, B: PartialEq<B> + PartialOrd<B>, D: PartialEq<D> + PartialOrd<D>, G: PartialEq<G> + PartialOrd<G>`
• `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 D: PartialEq<D> + PartialOrd<D>, I: PartialEq<I> + PartialOrd<I>, C: PartialEq<C> + PartialOrd<C>, F: PartialEq<F> + PartialOrd<F>, L: PartialEq<L> + PartialOrd<L>, G: PartialEq<G> + PartialOrd<G>, A: PartialEq<A> + PartialOrd<A>, B: PartialEq<B> + PartialOrd<B>, E: PartialEq<E> + PartialOrd<E>, J: PartialEq<J> + PartialOrd<J>, K: PartialEq<K> + PartialOrd<K>, H: PartialEq<H> + PartialOrd<H>`
• `impl<T> PartialOrd<Box<T>> for Box<T> where T: PartialOrd<T> + ?Sized`
• `impl<T> PartialOrd<Arc<T>> for Arc<T> where T: PartialOrd<T> + ?Sized`
• `impl<T> PartialOrd<Rc<T>> for Rc<T> where T: PartialOrd<T> + ?Sized`
• `impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where K: PartialOrd<K>, V: PartialOrd<V>`
• `impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where T: PartialOrd<T>`
• `impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where B: PartialOrd<B> + ToOwned + ?Sized`
• `impl<E> PartialOrd<EnumSet<E>> for EnumSet<E> where E: PartialOrd<E>`
• `impl<A> PartialOrd<LinkedList<A>> for LinkedList<A> where A: PartialOrd<A>`
• `impl PartialOrd<String> for String`
• `impl<T> PartialOrd<Vec<T>> for Vec<T> where T: PartialOrd<T>`
• `impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where A: PartialOrd<A>`
• `impl PartialOrd for CString`
• `impl PartialOrd for CStr`
• `impl PartialOrd for OsString`
• `impl PartialOrd<str> for OsString`
• `impl PartialOrd for OsStr`
• `impl PartialOrd<str> for OsStr`
• `impl PartialOrd for IpAddr`
• `impl PartialOrd for Ipv4Addr`
• `impl PartialOrd for Ipv6Addr`
• `impl<'a> PartialOrd for Prefix<'a>`
• `impl<'a> PartialOrd for PrefixComponent<'a>`
• `impl<'a> PartialOrd for Component<'a>`
• `impl<'a> PartialOrd for Components<'a>`
• `impl PartialOrd for PathBuf`
• `impl PartialOrd for Path`
• `impl PartialOrd for Duration`
• `impl PartialOrd for Instant`
• `impl PartialOrd for SystemTime`