/Rust

# Trait std::cmp::PartialOrd

```#[lang = "partial_ord"]
pub trait PartialOrd<Rhs = Self>: PartialEq<Rhs> where    Rhs: ?Sized, {
fn partial_cmp(&self, other: &Rhs) -> 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 { ... }
}```

Trait for values that can be compared for a sort-order.

The comparison must satisfy, for all `a`, `b` and `c`:

• antisymmetry: if `a < b` then `!(a > b)`, as well as `a > b` implying `!(a < b)`; and
• transitivity: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.

Note that these requirements mean that the trait itself must be implemented symmetrically and transitively: if `T: PartialOrd<U>` and `U: PartialOrd<V>` then `U: PartialOrd<T>` and `T: PartialOrd<V>`.

### Derivable

This trait can be used with `#[derive]`. When `derive`d on structs, it will produce a lexicographic ordering based on the top-to-bottom declaration order of the struct's members. When `derive`d on enums, variants are ordered by their top-to-bottom declaration order.

### How can I implement `PartialOrd`?

`PartialOrd` only requires implementation of the `partial_cmp` method, with the others generated from default implementations.

However it remains possible to implement the others separately for types which do not have a total order. For example, for floating point numbers, `NaN < 0 == false` and `NaN >= 0 == false` (cf. IEEE 754-2008 section 5.11).

`PartialOrd` requires your type to be `PartialEq`.

Implementations of `PartialEq`, `PartialOrd`, and `Ord` must agree with each other. It's easy to accidentally make them disagree by deriving some of the traits and manually implementing others.

If your type is `Ord`, you can implement `partial_cmp()` by using `cmp()`:

```use std::cmp::Ordering;

#[derive(Eq)]
struct Person {
id: u32,
name: String,
height: u32,
}

impl PartialOrd for Person {
fn partial_cmp(&self, other: &Person) -> Option<Ordering> {
Some(self.cmp(other))
}
}

impl Ord for Person {
fn cmp(&self, other: &Person) -> Ordering {
self.height.cmp(&other.height)
}
}

impl PartialEq for Person {
fn eq(&self, other: &Person) -> bool {
self.height == other.height
}
}```

You may also find it useful to use `partial_cmp()` on your type's fields. Here is an example of `Person` types who have a floating-point `height` field that is the only field to be used for sorting:

```use std::cmp::Ordering;

struct Person {
id: u32,
name: String,
height: f64,
}

impl PartialOrd for Person {
fn partial_cmp(&self, other: &Person) -> Option<Ordering> {
self.height.partial_cmp(&other.height)
}
}

impl PartialEq for Person {
fn eq(&self, other: &Person) -> bool {
self.height == other.height
}
}```

## Examples

```let x : u32 = 0;
let y : u32 = 1;

assert_eq!(x < y, true);
assert_eq!(x.lt(&y), true);```

## Required Methods

### `fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>`

This method returns an ordering between `self` and `other` values if one exists.

## Examples

```use std::cmp::Ordering;

let result = 1.0.partial_cmp(&2.0);
assert_eq!(result, Some(Ordering::Less));

let result = 1.0.partial_cmp(&1.0);
assert_eq!(result, Some(Ordering::Equal));

let result = 2.0.partial_cmp(&1.0);
assert_eq!(result, Some(Ordering::Greater));```

When comparison is impossible:

```let result = std::f64::NAN.partial_cmp(&1.0);
assert_eq!(result, None);```

## Provided Methods

### `fn lt(&self, other: &Rhs) -> bool`

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

## Examples

```let result = 1.0 < 2.0;
assert_eq!(result, true);

let result = 2.0 < 1.0;
assert_eq!(result, false);```

### `fn le(&self, other: &Rhs) -> bool`

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

## Examples

```let result = 1.0 <= 2.0;
assert_eq!(result, true);

let result = 2.0 <= 2.0;
assert_eq!(result, true);```

### `fn gt(&self, other: &Rhs) -> bool`

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

## Examples

```let result = 1.0 > 2.0;
assert_eq!(result, false);

let result = 2.0 > 2.0;
assert_eq!(result, false);```

### `fn ge(&self, other: &Rhs) -> bool`

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

## Examples

```let result = 2.0 >= 1.0;
assert_eq!(result, true);

let result = 2.0 >= 2.0;
assert_eq!(result, true);```

## Implementors

### `impl PartialOrd<str> for str` [src]

Implements comparison operations on strings.

Strings are compared lexicographically by their byte values. This compares Unicode code points based on their positions in the code charts. This is not necessarily the same as "alphabetical" order, which varies by language and locale. Comparing strings according to culturally-accepted standards requires locale-specific data that is outside the scope of the `str` type.

### `impl<T> PartialOrd<[T]> for [T] where    T: PartialOrd<T>, ` [src]

Implements comparison of vectors lexicographically.

## Panics

Panics if the value in either `RefCell` is currently borrowed.

## Panics

Panics if the value in either `RefCell` is currently borrowed.

## Panics

Panics if the value in either `RefCell` is currently borrowed.

## Panics

Panics if the value in either `RefCell` is currently borrowed.

## Panics

Panics if the value in either `RefCell` is currently borrowed.

### `impl<T> PartialOrd<Rc<T>> for Rc<T> where    T: PartialOrd<T> + ?Sized, ` [src]

#### `fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>` [src]

Partial comparison for two `Rc`s.

The two are compared by calling `partial_cmp()` on their inner values.

## Examples

```use std::rc::Rc;
use std::cmp::Ordering;

let five = Rc::new(5);

assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6)));```

#### `fn lt(&self, other: &Rc<T>) -> bool` [src]

Less-than comparison for two `Rc`s.

The two are compared by calling `<` on their inner values.

## Examples

```use std::rc::Rc;

let five = Rc::new(5);

assert!(five < Rc::new(6));```

#### `fn le(&self, other: &Rc<T>) -> bool` [src]

'Less than or equal to' comparison for two `Rc`s.

The two are compared by calling `<=` on their inner values.

## Examples

```use std::rc::Rc;

let five = Rc::new(5);

assert!(five <= Rc::new(5));```

#### `fn gt(&self, other: &Rc<T>) -> bool` [src]

Greater-than comparison for two `Rc`s.

The two are compared by calling `>` on their inner values.

## Examples

```use std::rc::Rc;

let five = Rc::new(5);

assert!(five > Rc::new(4));```

#### `fn ge(&self, other: &Rc<T>) -> bool` [src]

'Greater than or equal to' comparison for two `Rc`s.

The two are compared by calling `>=` on their inner values.

## Examples

```use std::rc::Rc;

let five = Rc::new(5);

assert!(five >= Rc::new(5));```

### `impl<T> PartialOrd<Arc<T>> for Arc<T> where    T: PartialOrd<T> + ?Sized, ` [src]

#### `fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>` [src]

Partial comparison for two `Arc`s.

The two are compared by calling `partial_cmp()` on their inner values.

## Examples

```use std::sync::Arc;
use std::cmp::Ordering;

let five = Arc::new(5);

assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));```

#### `fn lt(&self, other: &Arc<T>) -> bool` [src]

Less-than comparison for two `Arc`s.

The two are compared by calling `<` on their inner values.

## Examples

```use std::sync::Arc;

let five = Arc::new(5);

assert!(five < Arc::new(6));```

#### `fn le(&self, other: &Arc<T>) -> bool` [src]

'Less than or equal to' comparison for two `Arc`s.

The two are compared by calling `<=` on their inner values.

## Examples

```use std::sync::Arc;

let five = Arc::new(5);

assert!(five <= Arc::new(5));```

#### `fn gt(&self, other: &Arc<T>) -> bool` [src]

Greater-than comparison for two `Arc`s.

The two are compared by calling `>` on their inner values.

## Examples

```use std::sync::Arc;

let five = Arc::new(5);

assert!(five > Arc::new(4));```

#### `fn ge(&self, other: &Arc<T>) -> bool` [src]

'Greater than or equal to' comparison for two `Arc`s.

The two are compared by calling `>=` on their inner values.

## Examples

```use std::sync::Arc;

let five = Arc::new(5);

assert!(five >= Arc::new(5));```

### `impl<T> PartialOrd<Vec<T>> for Vec<T> where    T: PartialOrd<T>, ` [src]

Implements comparison of vectors, lexicographically.

### `impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where    R: PartialOrd<R>,    Y: PartialOrd<Y>, ` [src]

#### `fn ge(&self, other: &GeneratorState<Y, R>) -> bool` [src]

© 2010 The Rust Project Developers