Trait core::cmp::PartialOrd 1.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 asa > b
implying!(a < b)
; and - transitivity:
a < b
andb < c
impliesa < 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()
:
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 types fields. Here is an example of
Persontypes 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
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)