#[repr(i8)]pub enum Ordering {
Less = -1,
Equal = 0,
Greater = 1,
}
An Ordering is the result of a comparison between two values.
use std::cmp::Ordering; assert_eq!(1.cmp(&2), Ordering::Less); assert_eq!(1.cmp(&1), Ordering::Equal); assert_eq!(2.cmp(&1), Ordering::Greater);
Less = -1
An ordering where a compared value is less than another.
Equal = 0
An ordering where a compared value is equal to another.
Greater = 1
An ordering where a compared value is greater than another.
impl Ordering
pub const fn is_eq(self) -> bool
Returns true if the ordering is the Equal variant.
use std::cmp::Ordering; assert_eq!(Ordering::Less.is_eq(), false); assert_eq!(Ordering::Equal.is_eq(), true); assert_eq!(Ordering::Greater.is_eq(), false);
pub const fn is_ne(self) -> bool
Returns true if the ordering is not the Equal variant.
use std::cmp::Ordering; assert_eq!(Ordering::Less.is_ne(), true); assert_eq!(Ordering::Equal.is_ne(), false); assert_eq!(Ordering::Greater.is_ne(), true);
pub const fn is_lt(self) -> bool
Returns true if the ordering is the Less variant.
use std::cmp::Ordering; assert_eq!(Ordering::Less.is_lt(), true); assert_eq!(Ordering::Equal.is_lt(), false); assert_eq!(Ordering::Greater.is_lt(), false);
pub const fn is_gt(self) -> bool
Returns true if the ordering is the Greater variant.
use std::cmp::Ordering; assert_eq!(Ordering::Less.is_gt(), false); assert_eq!(Ordering::Equal.is_gt(), false); assert_eq!(Ordering::Greater.is_gt(), true);
pub const fn is_le(self) -> bool
Returns true if the ordering is either the Less or Equal variant.
use std::cmp::Ordering; assert_eq!(Ordering::Less.is_le(), true); assert_eq!(Ordering::Equal.is_le(), true); assert_eq!(Ordering::Greater.is_le(), false);
pub const fn is_ge(self) -> bool
Returns true if the ordering is either the Greater or Equal variant.
use std::cmp::Ordering; assert_eq!(Ordering::Less.is_ge(), false); assert_eq!(Ordering::Equal.is_ge(), true); assert_eq!(Ordering::Greater.is_ge(), true);
pub const fn reverse(self) -> Ordering
Reverses the Ordering.
Less becomes Greater.Greater becomes Less.Equal becomes Equal.Basic behavior:
use std::cmp::Ordering; assert_eq!(Ordering::Less.reverse(), Ordering::Greater); assert_eq!(Ordering::Equal.reverse(), Ordering::Equal); assert_eq!(Ordering::Greater.reverse(), Ordering::Less);
This method can be used to reverse a comparison:
let data: &mut [_] = &mut [2, 10, 5, 8]; // sort the array from largest to smallest. data.sort_by(|a, b| a.cmp(b).reverse()); let b: &mut [_] = &mut [10, 8, 5, 2]; assert!(data == b);
pub const fn then(self, other: Ordering) -> Ordering
Chains two orderings.
Returns self when it’s not Equal. Otherwise returns other.
use std::cmp::Ordering; let result = Ordering::Equal.then(Ordering::Less); assert_eq!(result, Ordering::Less); let result = Ordering::Less.then(Ordering::Equal); assert_eq!(result, Ordering::Less); let result = Ordering::Less.then(Ordering::Greater); assert_eq!(result, Ordering::Less); let result = Ordering::Equal.then(Ordering::Equal); assert_eq!(result, Ordering::Equal); let x: (i64, i64, i64) = (1, 2, 7); let y: (i64, i64, i64) = (1, 5, 3); let result = x.0.cmp(&y.0).then(x.1.cmp(&y.1)).then(x.2.cmp(&y.2)); assert_eq!(result, Ordering::Less);
pub fn then_with<F>(self, f: F) -> Orderingwhere
F: FnOnce() -> Ordering,Chains the ordering with the given function.
Returns self when it’s not Equal. Otherwise calls f and returns the result.
use std::cmp::Ordering; let result = Ordering::Equal.then_with(|| Ordering::Less); assert_eq!(result, Ordering::Less); let result = Ordering::Less.then_with(|| Ordering::Equal); assert_eq!(result, Ordering::Less); let result = Ordering::Less.then_with(|| Ordering::Greater); assert_eq!(result, Ordering::Less); let result = Ordering::Equal.then_with(|| Ordering::Equal); assert_eq!(result, Ordering::Equal); let x: (i64, i64, i64) = (1, 2, 7); let y: (i64, i64, i64) = (1, 5, 3); let result = x.0.cmp(&y.0).then_with(|| x.1.cmp(&y.1)).then_with(|| x.2.cmp(&y.2)); assert_eq!(result, Ordering::Less);
impl Clone for Ordering
fn clone(&self) -> Ordering
fn clone_from(&mut self, source: &Self)
source. Read more
impl Debug for Ordering
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
impl Hash for Ordering
fn hash<__H>(&self, state: &mut __H)where
__H: Hasher,fn hash_slice<H>(data: &[Self], state: &mut H)where
H: Hasher,
Self: Sized,impl Ord for Ordering
fn cmp(&self, other: &Ordering) -> Ordering
fn max(self, other: Self) -> Selfwhere
Self: Sized,fn min(self, other: Self) -> Selfwhere
Self: Sized,fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized,impl PartialEq for Ordering
fn eq(&self, other: &Ordering) -> bool
self and other values to be equal, and is used by ==.fn ne(&self, other: &Rhs) -> bool
!=. The default implementation is almost always sufficient, and should not be overridden without very good reason.impl PartialOrd for Ordering
fn partial_cmp(&self, other: &Ordering) -> 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
impl Copy for Ordering
impl Eq for Ordering
impl StructuralPartialEq for Ordering
impl Freeze for Ordering
impl RefUnwindSafe for Ordering
impl Send for Ordering
impl Sync for Ordering
impl Unpin for Ordering
impl UnwindSafe for Ordering
impl<T> Any for Twhere
T: 'static + ?Sized,impl<T> Borrow<T> for Twhere
T: ?Sized,impl<T> BorrowMut<T> for Twhere
T: ?Sized,impl<T> CloneToUninit for Twhere
T: Clone,unsafe fn clone_to_uninit(&self, dest: *mut u8)
clone_to_uninit #126799)
impl<T> From<T> for T
fn from(t: T) -> T
Returns the argument unchanged.
impl<T, U> Into<U> for Twhere
U: From<T>,fn into(self) -> U
Calls U::from(self).
That is, this conversion is whatever the implementation of From<T> for U chooses to do.
impl<T> ToOwned for Twhere
T: Clone,type Owned = T
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)
impl<T, U> TryFrom<U> for Twhere
U: Into<T>,type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,
© 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/enum.Ordering.html