impl Ordering

const fn is_eq(self: 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);

const fn is_ne(self: 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);

const fn is_lt(self: 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);

const fn is_gt(self: 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);

const fn is_le(self: 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);

const fn is_ge(self: 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);

const fn reverse(self: Self) -> Ordering

Reverses the Ordering.

• Less becomes Greater.
• Greater becomes Less.
• Equal becomes Equal.

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);

const fn then(self: 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);

const fn then_with<F>(self: Self, f: F) -> Ordering
where
    F: ~const FnOnce() -> 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);

impl Clone for Ordering

fn clone(self: &Self) -> Ordering

impl Copy for Ordering

impl Debug for Ordering

fn fmt(self: &Self, f: &mut $crate::fmt::Formatter<'_>) -> $crate::fmt::Result

impl Eq for Ordering

impl Freeze for Ordering

impl Hash for Ordering

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

impl Ord for Ordering

fn cmp(self: &Self, other: &Ordering) -> $crate::cmp::Ordering

impl PartialEq for Ordering

fn eq(self: &Self, other: &Ordering) -> bool

impl PartialOrd for Ordering

fn partial_cmp(self: &Self, other: &Ordering) -> $crate::option::Option<$crate::cmp::Ordering>

impl RefUnwindSafe for Ordering

impl Send for Ordering

impl StructuralPartialEq for Ordering

impl Sync for Ordering

impl Unpin for Ordering

impl UnwindSafe for Ordering

impl<T> Any for Ordering

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Ordering

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Ordering

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for Ordering

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for Ordering

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Ordering

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Ordering

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Ordering

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>