Enum std::cmp::Ordering

pub enum Ordering {
    Less,
    Equal,
    Greater,
}

An Ordering is the result of a comparison between two values.

Examples

use std::cmp::Ordering;

let result = 1.cmp(&2);
assert_eq!(Ordering::Less, result);

let result = 1.cmp(&1);
assert_eq!(Ordering::Equal, result);

let result = 2.cmp(&1);
assert_eq!(Ordering::Greater, result);

Variants

Less	An ordering where a compared value is less [than another].
Equal	An ordering where a compared value is equal [to another].
Greater	An ordering where a compared value is greater [than another].

Methods

impl Ordering

fn reverse(self) -> Ordering

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

Trait Implementations

impl Eq for Ordering

fn assert_receiver_is_total_eq(&self)

impl Ord for Ordering

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

impl PartialOrd<Ordering> 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

Derived Implementations

impl Debug for Ordering

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

impl PartialEq<Ordering> for Ordering

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

fn ne(&self, __arg_0: &Ordering) -> bool

impl Copy for Ordering

impl Clone for Ordering

fn clone(&self) -> Ordering

fn clone_from(&mut self, source: &Self)