# 1.0.0[−][src]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);Run

## 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[src]

#### pub fn reverse(self) -> Ordering[src]

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

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

#### pub fn then(self, other: Ordering) -> Ordering1.17.0[src]

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

#### pub fn then_with<F>(self, f: F) -> Ordering where    F: FnOnce() -> Ordering, 1.17.0[src]

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

## Trait Implementations

### impl Clone for Ordering[src]

#### fn clone_from(&mut self, source: &Self)[src]

Performs copy-assignment from source. Read more

### impl Hash for Ordering[src]

#### fn hash_slice<H>(data: &[Self], state: &mut H) where    H: Hasher, 1.3.0[src]

Feeds a slice of this type into the given [Hasher]. Read more

### impl PartialEq<Ordering> for Ordering[src]

#### #[must_use] fn ne(&self, other: &Rhs) -> bool[src]

This method tests for !=.

### impl PartialOrd<Ordering> for Ordering[src]

#### #[must_use] fn lt(&self, other: &Rhs) -> bool[src]

This method tests less than (for self and other) and is used by the < operator. Read more

#### #[must_use] fn le(&self, other: &Rhs) -> bool[src]

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

#### #[must_use] fn gt(&self, other: &Rhs) -> bool[src]

This method tests greater than (for self and other) and is used by the > operator. Read more

#### #[must_use] fn ge(&self, other: &Rhs) -> bool[src]

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

### impl Ord for Ordering[src]

#### fn max(self, other: Self) -> Self1.21.0[src]

Compares and returns the maximum of two values. Read more

#### fn min(self, other: Self) -> Self1.21.0[src]

Compares and returns the minimum of two values. Read more

#### fn clamp(self, min: Self, max: Self) -> Self[src]

🔬 This is a nightly-only experimental API. (clamp #44095)

Restrict a value to a certain interval. Read more

## Blanket Implementations

### impl<T, U> TryFrom<U> for T where    U: Into<T>, [src]

#### type Error = Infallible

The type returned in the event of a conversion error.

### impl<T, U> TryInto<U> for T where    U: TryFrom<T>, [src]

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

### impl<T> ToOwned for T where    T: Clone, [src]

#### type Owned = T

The resulting type after obtaining ownership.