#[repr(i8)]pub enum Ordering {
Less = -1,
Equal = 0,
Greater = 1,
}
Expand description
An Ordering
is the result of a comparison between two values.
§Examples
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);
Variants§
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.
Implementations§
source§impl Ordering
impl Ordering
1.53.0 (const: 1.53.0) · sourcepub const fn is_eq(self) -> bool
pub const fn is_eq(self) -> bool
Returns true
if the ordering is the Equal
variant.
§Examples
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);
1.53.0 (const: 1.53.0) · sourcepub const fn is_ne(self) -> bool
pub const fn is_ne(self) -> bool
Returns true
if the ordering is not the Equal
variant.
§Examples
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);
1.53.0 (const: 1.53.0) · sourcepub const fn is_lt(self) -> bool
pub const fn is_lt(self) -> bool
Returns true
if the ordering is the Less
variant.
§Examples
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);
1.53.0 (const: 1.53.0) · sourcepub const fn is_gt(self) -> bool
pub const fn is_gt(self) -> bool
Returns true
if the ordering is the Greater
variant.
§Examples
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);
1.53.0 (const: 1.53.0) · sourcepub const fn is_le(self) -> bool
pub const fn is_le(self) -> bool
Returns true
if the ordering is either the Less
or Equal
variant.
§Examples
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);
1.53.0 (const: 1.53.0) · sourcepub const fn is_ge(self) -> bool
pub const fn is_ge(self) -> bool
Returns true
if the ordering is either the Greater
or Equal
variant.
§Examples
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);
1.0.0 (const: 1.48.0) · sourcepub const fn reverse(self) -> Ordering
pub const fn reverse(self) -> Ordering
Reverses the Ordering
.
Less
becomesGreater
.Greater
becomesLess
.Equal
becomesEqual
.
§Examples
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);
1.17.0 (const: 1.48.0) · sourcepub const fn then(self, other: Ordering) -> Ordering
pub const fn then(self, other: Ordering) -> Ordering
Chains two orderings.
Returns self
when it’s not Equal
. Otherwise returns other
.
§Examples
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);
1.17.0 · sourcepub fn then_with<F>(self, f: F) -> Ordering
pub fn then_with<F>(self, f: F) -> Ordering
Chains the ordering with the given function.
Returns self
when it’s not Equal
. Otherwise calls f
and returns
the result.
§Examples
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);
Trait Implementations§
source§impl ConditionallySelectable for Ordering
impl ConditionallySelectable for Ordering
Ordering
is #[repr(i8)]
where:
Less
=> -1Equal
=> 0Greater
=> 1
Given this, it’s possible to operate on orderings as if they’re integers, which allows leveraging conditional masking for predication.
source§impl ConstantTimeEq for Ordering
impl ConstantTimeEq for Ordering
Ordering
is #[repr(i8)]
making it possible to leverage i8::ct_eq
.
source§impl ConstantTimeGreater for Ordering
impl ConstantTimeGreater for Ordering
source§impl ConstantTimeLess for Ordering
impl ConstantTimeLess for Ordering
1.0.0 · source§impl Ord for Ordering
impl Ord for Ordering
1.0.0 · source§impl PartialEq for Ordering
impl PartialEq for Ordering
1.0.0 · source§impl PartialOrd for Ordering
impl PartialOrd for Ordering
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moreimpl Copy for Ordering
impl Eq for Ordering
impl StructuralPartialEq for Ordering
Auto Trait Implementations§
impl Freeze for Ordering
impl RefUnwindSafe for Ordering
impl Send for Ordering
impl Sync for Ordering
impl Unpin for Ordering
impl UnwindSafe for Ordering
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.