Trait core::cmp::PartialOrd1.0.0 [−] [src]

```pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
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>`.

Derivable

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

How can I implement `Ord`?

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()`:

fn main() { 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 } } }
```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:

fn main() { 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 } } }
```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

fn main() { let x : u32 = 0; let y : u32 = 1; assert_eq!(x < y, true); assert_eq!(x.lt(&y), true); }
```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

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> PartialOrd for Wrapping<T>`
• `impl<T: PartialOrd + Zeroable> PartialOrd for NonZero<T>`
• `impl<Ret> PartialOrd for fn() -> Ret`
• `impl<Ret> PartialOrd for extern fn() -> Ret`
• `impl<Ret> PartialOrd for unsafe fn() -> Ret`
• `impl<Ret> PartialOrd for unsafe extern fn() -> Ret`
• `impl<Ret, A> PartialOrd for fn(A) -> Ret`
• `impl<Ret, A> PartialOrd for extern fn(A) -> Ret`
• `impl<Ret, A> PartialOrd for unsafe fn(A) -> Ret`
• `impl<Ret, A> PartialOrd for unsafe extern fn(A) -> Ret`
• `impl<Ret, A, B> PartialOrd for fn(A, B) -> Ret`
• `impl<Ret, A, B> PartialOrd for extern fn(A, B) -> Ret`
• `impl<Ret, A, B> PartialOrd for unsafe fn(A, B) -> Ret`
• `impl<Ret, A, B> PartialOrd for unsafe extern fn(A, B) -> Ret`
• `impl<Ret, A, B, C> PartialOrd for fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C> PartialOrd for extern fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C> PartialOrd for unsafe fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C> PartialOrd for unsafe extern fn(A, B, C) -> Ret`
• `impl<Ret, A, B, C, D> PartialOrd for fn(A, B, C, D) -> Ret`
• `impl<Ret, A, B, C, D> PartialOrd for extern fn(A, B, C, D) -> Ret`
• `impl<Ret, A, B, C, D> PartialOrd for unsafe fn(A, B, C, D) -> Ret`
• `impl<Ret, A, B, C, D> PartialOrd for unsafe extern fn(A, B, C, D) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialOrd for fn(A, B, C, D, E) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialOrd for extern fn(A, B, C, D, E) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialOrd for unsafe fn(A, B, C, D, E) -> Ret`
• `impl<Ret, A, B, C, D, E> PartialOrd for unsafe extern fn(A, B, C, D, E) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialOrd for fn(A, B, C, D, E, F) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialOrd for extern fn(A, B, C, D, E, F) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialOrd for unsafe fn(A, B, C, D, E, F) -> Ret`
• `impl<Ret, A, B, C, D, E, F> PartialOrd for unsafe extern fn(A, B, C, D, E, F) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialOrd for fn(A, B, C, D, E, F, G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialOrd for extern fn(A, B, C, D, E, F, G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialOrd for unsafe fn(A, B, C, D, E, F, G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G> PartialOrd for unsafe extern fn(A, B, C, D, E, F, G) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialOrd for fn(A, B, C, D, E, F, G, H) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialOrd for extern fn(A, B, C, D, E, F, G, H) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialOrd for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H> PartialOrd 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 for fn(A, B, C, D, E, F, G, H, I) -> Ret`
• `impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd 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 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 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 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 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 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 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 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 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 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 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 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 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 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 for unsafe extern fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`
• `impl<T: ?Sized> PartialOrd for *const T`
• `impl<T: ?Sized> PartialOrd for *mut T`
• `impl<T: ?Sized> PartialOrd for PhantomData<T>`
• `impl PartialOrd for ()`
• `impl PartialOrd for bool`
• `impl PartialOrd for f32`
• `impl PartialOrd for f64`
• `impl PartialOrd for char`
• `impl PartialOrd for usize`
• `impl PartialOrd for u8`
• `impl PartialOrd for u16`
• `impl PartialOrd for u32`
• `impl PartialOrd for u64`
• `impl PartialOrd for isize`
• `impl PartialOrd for i8`
• `impl PartialOrd for i16`
• `impl PartialOrd for i32`
• `impl PartialOrd for i64`
• `impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b B> for &'a A where A: PartialOrd<B>`
• `impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b mut B> for &'a mut A where A: PartialOrd<B>`
• `impl PartialOrd for Ordering`
• `impl<T: PartialOrd> PartialOrd for [T; 0]`
• `impl<T: PartialOrd> PartialOrd for [T; 1]`
• `impl<T: PartialOrd> PartialOrd for [T; 2]`
• `impl<T: PartialOrd> PartialOrd for [T; 3]`
• `impl<T: PartialOrd> PartialOrd for [T; 4]`
• `impl<T: PartialOrd> PartialOrd for [T; 5]`
• `impl<T: PartialOrd> PartialOrd for [T; 6]`
• `impl<T: PartialOrd> PartialOrd for [T; 7]`
• `impl<T: PartialOrd> PartialOrd for [T; 8]`
• `impl<T: PartialOrd> PartialOrd for [T; 9]`
• `impl<T: PartialOrd> PartialOrd for [T; 10]`
• `impl<T: PartialOrd> PartialOrd for [T; 11]`
• `impl<T: PartialOrd> PartialOrd for [T; 12]`
• `impl<T: PartialOrd> PartialOrd for [T; 13]`
• `impl<T: PartialOrd> PartialOrd for [T; 14]`
• `impl<T: PartialOrd> PartialOrd for [T; 15]`
• `impl<T: PartialOrd> PartialOrd for [T; 16]`
• `impl<T: PartialOrd> PartialOrd for [T; 17]`
• `impl<T: PartialOrd> PartialOrd for [T; 18]`
• `impl<T: PartialOrd> PartialOrd for [T; 19]`
• `impl<T: PartialOrd> PartialOrd for [T; 20]`
• `impl<T: PartialOrd> PartialOrd for [T; 21]`
• `impl<T: PartialOrd> PartialOrd for [T; 22]`
• `impl<T: PartialOrd> PartialOrd for [T; 23]`
• `impl<T: PartialOrd> PartialOrd for [T; 24]`
• `impl<T: PartialOrd> PartialOrd for [T; 25]`
• `impl<T: PartialOrd> PartialOrd for [T; 26]`
• `impl<T: PartialOrd> PartialOrd for [T; 27]`
• `impl<T: PartialOrd> PartialOrd for [T; 28]`
• `impl<T: PartialOrd> PartialOrd for [T; 29]`
• `impl<T: PartialOrd> PartialOrd for [T; 30]`
• `impl<T: PartialOrd> PartialOrd for [T; 31]`
• `impl<T: PartialOrd> PartialOrd for [T; 32]`
• `impl<T: PartialOrd + Copy> PartialOrd for Cell<T>`
• `impl<T: ?Sized + PartialOrd> PartialOrd for RefCell<T>`
• `impl<T: PartialOrd> PartialOrd for Option<T>`
• `impl<T: PartialOrd, E: PartialOrd> PartialOrd for Result<T, E>`
• `impl<T: PartialOrd> PartialOrd for [T]`
• `impl PartialOrd for str`
• `impl PartialOrd for Error`
• `impl<A: PartialOrd + PartialEq> PartialOrd for (A,)`
• `impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq> PartialOrd for (A, B)`
• `impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq> PartialOrd for (A, B, C)`
• `impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq> PartialOrd for (A, B, C, D)`
• `impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E)`
• `impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F)`
• `impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq> PartialOrd for (A, B, C, D, E, F, G)`
• `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> PartialOrd for (A, B, C, D, E, F, G, H)`
• `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> PartialOrd for (A, B, C, D, E, F, G, H, I)`
• `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> PartialOrd for (A, B, C, D, E, F, G, H, I, J)`
• `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> PartialOrd for (A, B, C, D, E, F, G, H, I, J, K)`
• `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 + PartialEq> PartialOrd for (A, B, C, D, E, F, G, H, I, J, K, L)`