W3cubDocs

/Rust

Trait std::cmp::PartialOrd

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 and U: PartialOrd<V> then U: PartialOrd<T> and T: PartialOrd<V>.

Derivable

This trait can be used with #[derive]. When derived, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct's members.

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.

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

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

Examples

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

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

Required Methods

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

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

Examples

use std::cmp::Ordering;

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

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

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

When comparison is impossible:

let result = 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

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

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

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

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

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

Implementors

impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where K: PartialOrd<K>, V: PartialOrd<V>
impl<'a, B> PartialOrd<Cow<'a, B>> for std::borrow::Cow<'a, B> where B: PartialOrd + ToOwned + ?Sized
impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where T: PartialOrd<T>
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<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where T: PartialOrd<T>
impl<E> PartialOrd<EnumSet<E>> for EnumSet<E> where E: PartialOrd<E>
impl PartialOrd<String> for String
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<T> PartialOrd<*const T> for *const T where T: ?Sized
impl<T> PartialOrd<*mut T> for *mut T where T: ?Sized
impl PartialOrd<Ordering> for Ordering
impl PartialOrd<()> for ()
impl PartialOrd<bool> for bool
impl PartialOrd<!> for !
impl<'a, 'b, A, B> PartialOrd<&'b B> for &'a A where A: PartialOrd + ?Sized, B: ?Sized
impl<'a, 'b, A, B> PartialOrd<&'b mut B> for &'a mut A where A: PartialOrd + ?Sized, B: ?Sized
impl<T> PartialOrd<Cell<T>> for Cell<T> where T: Copy + PartialOrd<T>
impl<T> PartialOrd<RefCell<T>> for RefCell<T> where T: PartialOrd<T> + ?Sized
impl<T> PartialOrd<[T]> for [T] where T: PartialOrd<T>
impl PartialOrd<str> for str
impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where T: PartialOrd<T>
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 fn() -> Ret> for extern fn() -> Ret
impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
impl<Ret> PartialOrd<unsafe extern fn() -> Ret> for unsafe extern fn() -> Ret
impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret
impl<Ret, A> PartialOrd<extern fn(A) -> Ret> for extern fn(A) -> Ret
impl<Ret, A> PartialOrd<extern fn(A, ...) -> Ret> for extern fn(A, ...) -> Ret
impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
impl<Ret, A> PartialOrd<unsafe extern fn(A) -> Ret> for unsafe extern fn(A) -> Ret
impl<Ret, A> PartialOrd<unsafe extern fn(A, ...) -> Ret> for unsafe extern fn(A, ...) -> Ret
impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret
impl<Ret, A, B> PartialOrd<extern fn(A, B) -> Ret> for extern fn(A, B) -> Ret
impl<Ret, A, B> PartialOrd<extern fn(A, B, ...) -> Ret> for extern 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 fn(A, B) -> Ret> for unsafe extern fn(A, B) -> Ret
impl<Ret, A, B> PartialOrd<unsafe extern fn(A, B, ...) -> Ret> for unsafe extern 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 fn(A, B, C) -> Ret> for extern fn(A, B, C) -> Ret
impl<Ret, A, B, C> PartialOrd<extern fn(A, B, C, ...) -> Ret> for extern 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 fn(A, B, C) -> Ret> for unsafe extern fn(A, B, C) -> Ret
impl<Ret, A, B, C> PartialOrd<unsafe extern fn(A, B, C, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D) -> Ret> for extern fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> PartialOrd<extern fn(A, B, C, D, ...) -> Ret> for extern 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 fn(A, B, C, D) -> Ret> for unsafe extern fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> PartialOrd<unsafe extern fn(A, B, C, D, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E) -> Ret> for extern fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D, E> PartialOrd<extern fn(A, B, C, D, E, ...) -> Ret> for extern 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 fn(A, B, C, D, E) -> Ret> for unsafe extern fn(A, B, C, D, E) -> Ret
impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern fn(A, B, C, D, E, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F) -> Ret> for extern fn(A, B, C, D, E, F) -> Ret
impl<Ret, A, B, C, D, E, F> PartialOrd<extern fn(A, B, C, D, E, F, ...) -> Ret> for extern 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 fn(A, B, C, D, E, F) -> Ret> for unsafe extern fn(A, B, C, D, E, F) -> Ret
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G) -> Ret> for extern fn(A, B, C, D, E, F, G) -> Ret
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern fn(A, B, C, D, E, F, G, ...) -> Ret> for extern 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 fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern fn(A, B, C, D, E, F, G) -> Ret
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H) -> Ret> for extern fn(A, B, C, D, E, F, G, H) -> Ret
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern fn(A, B, C, D, E, F, G, H) -> Ret
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern fn(A, B, C, D, E, F, G, H, I) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern 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 fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern 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 fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where T: ?Sized
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 PartialOrd<u128> for u128
impl PartialOrd<i128> for i128
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 E: PartialOrd<E>, T: PartialOrd<T>
impl PartialOrd<Error> for Error
impl<A> PartialOrd<(A,)> for (A,) where A: PartialEq<A> + PartialOrd<A>
impl<A, B> PartialOrd<(A, B)> for (A, B) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd
impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>
impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>
impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>
impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>
impl<A, B, C, D, E, F, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>
impl<A, B, C, D, E, F, G, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, H: PartialEq<H> + PartialOrd<H>
impl<A, B, C, D, E, F, G, H, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, H: PartialEq<H> + PartialOrd<H>, I: PartialEq + PartialOrd
impl<A, B, C, D, E, F, G, H, I, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, H: PartialEq<H> + PartialOrd<H>, I: PartialEq + PartialOrd, J: PartialEq<J> + PartialOrd<J>
impl<A, B, C, D, E, F, G, H, I, J, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, H: PartialEq<H> + PartialOrd<H>, I: PartialEq + PartialOrd, J: PartialEq<J> + PartialOrd<J>, K: PartialEq<K> + PartialOrd<K>
impl<A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where A: PartialEq<A> + PartialOrd<A>, B: PartialEq + PartialOrd, C: PartialEq<C> + PartialOrd<C>, D: PartialEq<D> + PartialOrd<D>, E: PartialEq<E> + PartialOrd<E>, F: PartialEq<F> + PartialOrd<F>, G: PartialEq<G> + PartialOrd<G>, H: PartialEq<H> + PartialOrd<H>, I: PartialEq + PartialOrd, J: PartialEq<J> + PartialOrd<J>, K: PartialEq<K> + PartialOrd<K>, L: PartialEq<L> + PartialOrd<L>
impl PartialOrd for CString
impl PartialOrd for CStr
impl PartialOrd for std::ffi::OsString
impl PartialOrd<str> for std::ffi::OsString
impl PartialOrd for std::ffi::OsStr
impl PartialOrd<str> for std::ffi::OsStr
impl<'a, 'b> PartialOrd<OsStr> for std::ffi::OsString
impl<'a, 'b> PartialOrd<OsString> for std::ffi::OsStr
impl<'a, 'b> PartialOrd<&'a OsStr> for std::ffi::OsString
impl<'a, 'b> PartialOrd<OsString> for &'a OsStr
impl<'a, 'b> PartialOrd<OsStr> for std::borrow::Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for std::ffi::OsStr
impl<'a, 'b> PartialOrd<&'b OsStr> for std::borrow::Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr
impl<'a, 'b> PartialOrd<OsString> for std::borrow::Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for std::ffi::OsString
impl PartialOrd for ErrorKind
impl PartialOrd for std::net::IpAddr
impl PartialOrd for std::net::Ipv4Addr
impl PartialOrd<Ipv4Addr> for std::net::IpAddr
impl PartialOrd<IpAddr> for std::net::Ipv4Addr
impl PartialOrd for std::net::Ipv6Addr
impl PartialOrd<Ipv6Addr> for std::net::IpAddr
impl PartialOrd<IpAddr> for std::net::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 std::path::PathBuf
impl PartialOrd for std::path::Path
impl<'a, 'b> PartialOrd<Path> for std::path::PathBuf
impl<'a, 'b> PartialOrd<PathBuf> for std::path::Path
impl<'a, 'b> PartialOrd<&'a Path> for std::path::PathBuf
impl<'a, 'b> PartialOrd<PathBuf> for &'a Path
impl<'a, 'b> PartialOrd<Path> for std::borrow::Cow<'a, Path>
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for std::path::Path
impl<'a, 'b> PartialOrd<&'b Path> for std::borrow::Cow<'a, Path>
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
impl<'a, 'b> PartialOrd<PathBuf> for std::borrow::Cow<'a, Path>
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for std::path::PathBuf
impl<'a, 'b> PartialOrd<OsStr> for std::path::PathBuf
impl<'a, 'b> PartialOrd<PathBuf> for std::ffi::OsStr
impl<'a, 'b> PartialOrd<&'a OsStr> for std::path::PathBuf
impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for std::path::PathBuf
impl<'a, 'b> PartialOrd<PathBuf> for std::borrow::Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<OsString> for std::path::PathBuf
impl<'a, 'b> PartialOrd<PathBuf> for std::ffi::OsString
impl<'a, 'b> PartialOrd<OsStr> for std::path::Path
impl<'a, 'b> PartialOrd<Path> for std::ffi::OsStr
impl<'a, 'b> PartialOrd<&'a OsStr> for std::path::Path
impl<'a, 'b> PartialOrd<Path> for &'a OsStr
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for std::path::Path
impl<'a, 'b> PartialOrd<Path> for std::borrow::Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<OsString> for std::path::Path
impl<'a, 'b> PartialOrd<Path> for std::ffi::OsString
impl<'a, 'b> PartialOrd<OsStr> for &'a Path
impl<'a, 'b> PartialOrd<&'a Path> for std::ffi::OsStr
impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path
impl<'a, 'b> PartialOrd<&'a Path> for std::borrow::Cow<'b, OsStr>
impl<'a, 'b> PartialOrd<OsString> for &'a Path
impl<'a, 'b> PartialOrd<&'a Path> for std::ffi::OsString
impl<'a, 'b> PartialOrd<OsStr> for std::borrow::Cow<'a, Path>
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for std::ffi::OsStr
impl<'a, 'b> PartialOrd<&'b OsStr> for std::borrow::Cow<'a, Path>
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
impl<'a, 'b> PartialOrd<OsString> for std::borrow::Cow<'a, Path>
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for std::ffi::OsString
impl PartialOrd for Duration
impl PartialOrd for Instant
impl PartialOrd for SystemTime

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html

Trait std::cmp::PartialOrd

Derivable

How can I implement PartialOrd?

Examples

Required Methods

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

Examples

Provided Methods

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

Examples

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

Examples

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

Examples

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

Examples

Implementors

How can I implement `PartialOrd`?

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