Trait nom::lib::std::prelude::v1::v1::Ord

#[lang = "ord"]
pub trait Ord: Eq + PartialOrd<Self> {
    fn cmp(&self, other: &Self) -> Ordering;

    fn max(self, other: Self) -> Self { ... }
    fn min(self, other: Self) -> Self { ... }
}

Trait for types that form a total order.

An order is a total order if it is (for all a, b and c):

• total and antisymmetric: exactly one of a < b, a == b or a > b is true; and
• transitive, a < b and b < c implies a < c. The same must hold for both == and >.

Derivable

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

How can I implement Ord?

Ord requires that the type also be PartialOrd and Eq (which requires PartialEq).

Then you must define an implementation for cmp(). You may find it useful to use cmp() on your type's fields.

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.

Here's an example where you want to sort people by height only, disregarding id and name:

use std::cmp::Ordering;

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

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

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

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

Required Methods

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

This method returns an Ordering between self and other.

By convention, self.cmp(&other) returns the ordering matching the expression self <operator> other if true.

Examples

use std::cmp::Ordering;

assert_eq!(5.cmp(&10), Ordering::Less);
assert_eq!(10.cmp(&5), Ordering::Greater);
assert_eq!(5.cmp(&5), Ordering::Equal);

Provided Methods

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

Returns the second argument if the comparison determines them to be equal.

Examples

assert_eq!(2, 1.max(2));
assert_eq!(2, 2.max(2));

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

Returns the first argument if the comparison determines them to be equal.

Examples

assert_eq!(1, 1.min(2));
assert_eq!(2, 2.min(2));

Implementations on Foreign Types

impl Ord for ErrorKind

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Ipv4Addr

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for Components<'a>

fn cmp(&self, other: &Components<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for IpAddr

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for PrefixComponent<'a>

fn cmp(&self, other: &PrefixComponent<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for CStr

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for CString

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Ipv6Addr

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for SystemTime

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for Prefix<'a>

fn cmp(&self, other: &Prefix<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Path

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for PathBuf

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for OsStr

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for OsString

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Instant

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a> Ord for Component<'a>

fn cmp(&self, other: &Component<'a>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for unsafe fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 32] where     T: Ord,

fn cmp(&self, other: &[T; 32]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 20] where     T: Ord,

fn cmp(&self, other: &[T; 20]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 31] where     T: Ord,

fn cmp(&self, other: &[T; 31]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u64

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 11] where     T: Ord,

fn cmp(&self, other: &[T; 11]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for ()

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 3] where     T: Ord,

fn cmp(&self, other: &[T; 3]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for PhantomData<T> where     T: ?Sized,

fn cmp(&self, _other: &PhantomData<T>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for extern "C" fn(A) -> Ret

fn cmp(&self, other: &extern "C" fn(A) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T] where     T: Ord,

Implements comparison of vectors lexicographically.

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 5] where     T: Ord,

fn cmp(&self, other: &[T; 5]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for !

fn cmp(&self, &!) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 28] where     T: Ord,

fn cmp(&self, other: &[T; 28]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 6] where     T: Ord,

fn cmp(&self, other: &[T; 6]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for extern "C" fn() -> Ret

fn cmp(&self, other: &extern "C" fn() -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 22] where     T: Ord,

fn cmp(&self, other: &[T; 22]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn cmp(     &self,     other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for RefCell<T> where     T: Ord + ?Sized,

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

Panics

Panics if the value in either RefCell is currently borrowed.

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E, F, G, H, I> Ord for (A, B, C, D, E, F, G, H, I) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord,     F: Ord,     G: Ord,     H: Ord,     I: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Duration

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for unsafe fn(A, B, C) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for NonZeroU16

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i128

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for fn(A, B) -> Ret

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for bool

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for fn(A, B, C, D) -> Ret

fn cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 29] where     T: Ord,

fn cmp(&self, other: &[T; 29]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for fn(A, B, C, D, E, F, G, H, I, J) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i16

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a, A> Ord for &'a A where     A: Ord + ?Sized,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 27] where     T: Ord,

fn cmp(&self, other: &[T; 27]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i32

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for extern "C" fn(A, B) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 15] where     T: Ord,

fn cmp(&self, other: &[T; 15]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for char

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u128

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 2] where     T: Ord,

fn cmp(&self, other: &[T; 2]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a, A> Ord for &'a mut A where     A: Ord + ?Sized,

fn cmp(&self, other: &&'a mut A) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D> Ord for (A, B, C, D) where     A: Ord,     B: Ord,     C: Ord,     D: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for unsafe extern "C" fn(A) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 0] where     T: Ord,

fn cmp(&self, other: &[T; 0]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u16

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for fn(A) -> Ret

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B> Ord for (A, B) where     A: Ord,     B: Ord + ?Sized,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for extern "C" fn(A, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for usize

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for *const T where     T: ?Sized,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 9] where     T: Ord,

fn cmp(&self, other: &[T; 9]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 23] where     T: Ord,

fn cmp(&self, other: &[T; 23]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 12] where     T: Ord,

fn cmp(&self, other: &[T; 12]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i8

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for NonZeroU64

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for NonZeroU128

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 19] where     T: Ord,

fn cmp(&self, other: &[T; 19]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 30] where     T: Ord,

fn cmp(&self, other: &[T; 30]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for i64

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 13] where     T: Ord,

fn cmp(&self, other: &[T; 13]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u8

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E, F, G, H, I, J> Ord for (A, B, C, D, E, F, G, H, I, J) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord,     F: Ord,     G: Ord,     H: Ord,     I: Ord,     J: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 7] where     T: Ord,

fn cmp(&self, other: &[T; 7]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for unsafe fn() -> Ret

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for str

Implements ordering of strings.

Strings are ordered lexicographically by their byte values. This orders 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. Sorting strings according to culturally-accepted standards requires locale-specific data that is outside the scope of the str type.

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Cell<T> where     T: Copy + Ord,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for u32

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C> Ord for fn(A, B, C) -> Ret

fn cmp(&self, other: &fn(A, B, C) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for extern "C" fn(A, B, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E> Ord for (A, B, C, D, E) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 17] where     T: Ord,

fn cmp(&self, other: &[T; 17]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for *mut T where     T: ?Sized,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret

fn cmp(     &self,     other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for NonZeroUsize

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret

fn cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for UnicodeVersion

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D> Ord for unsafe fn(A, B, C, D) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E, F, G, H> Ord for (A, B, C, D, E, F, G, H) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord,     F: Ord,     G: Ord,     H: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for unsafe extern "C" fn(A, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 14] where     T: Ord,

fn cmp(&self, other: &[T; 14]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 10] where     T: Ord,

fn cmp(&self, other: &[T; 10]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 24] where     T: Ord,

fn cmp(&self, other: &[T; 24]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 26] where     T: Ord,

fn cmp(&self, other: &[T; 26]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for isize

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 4] where     T: Ord,

fn cmp(&self, other: &[T; 4]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E, F, G, H, I, J, K, L> Ord for (A, B, C, D, E, F, G, H, I, J, K, L) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord,     F: Ord,     G: Ord,     H: Ord,     I: Ord,     J: Ord,     K: Ord,     L: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for fn() -> Ret

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E, F, G> Ord for (A, B, C, D, E, F, G) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord,     F: Ord,     G: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E, F, G)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A> Ord for (A,) where     A: Ord + ?Sized,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Pinned

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for TypeId

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 18] where     T: Ord,

fn cmp(&self, other: &[T; 18]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E, ...) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B, ...) -> Ret

fn cmp(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

fn cmp(     &self,     other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 1] where     T: Ord,

fn cmp(&self, other: &[T; 1]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A> Ord for unsafe fn(A) -> Ret

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 16] where     T: Ord,

fn cmp(&self, other: &[T; 16]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 21] where     T: Ord,

fn cmp(&self, other: &[T; 21]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for NonZeroU32

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 8] where     T: Ord,

fn cmp(&self, other: &[T; 8]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C> Ord for (A, B, C) where     A: Ord,     B: Ord,     C: Ord + ?Sized,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

fn cmp(     &self,     other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E, F> Ord for (A, B, C, D, E, F) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord,     F: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E, F)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for [T; 25] where     T: Ord,

fn cmp(&self, other: &[T; 25]) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for NonZeroU8

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<A, B, C, D, E, F, G, H, I, J, K> Ord for (A, B, C, D, E, F, G, H, I, J, K) where     A: Ord,     B: Ord,     C: Ord,     D: Ord,     E: Ord,     F: Ord,     G: Ord,     H: Ord,     I: Ord,     J: Ord,     K: Ord + ?Sized,

fn cmp(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F) -> Ret

fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret> Ord for unsafe extern "C" fn() -> Ret

fn cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

fn cmp(     &self,     other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for NonNull<T> where     T: ?Sized,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<Ret, A, B, C, D, E, F, G> Ord for unsafe fn(A, B, C, D, E, F, G) -> Ret

fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Wrapping<T> where     T: Ord,

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Rc<T> where     T: Ord + ?Sized,

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

Comparison for two Rcs.

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

Examples

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

let five = Rc::new(5);

assert_eq!(Ordering::Less, five.cmp(&Rc::new(6)));

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<'a, B> Ord for Cow<'a, B> where     B: Ord + ToOwned + ?Sized,

fn cmp(&self, other: &Cow<'a, B>) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl<T> Ord for Arc<T> where     T: Ord + ?Sized,

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

Comparison for two Arcs.

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

Examples

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

let five = Arc::new(5);

assert_eq!(Ordering::Less, five.cmp(&Arc::new(6)));

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Span

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for ClassUnicodeRange

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for ClassBytesRange

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Literal

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

impl Ord for Position

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

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

Implementors

• impl Ord for NoneError

• impl Ord for Ordering

• impl<T> Ord for Reverse<T> where     T: Ord,

• impl Ord for Error

• impl<T> Ord for ManuallyDrop<T> where     T: Ord,

• impl<T> Ord for Option<T> where     T: Ord,

• impl<Y, R> Ord for GeneratorState<Y, R> where     R: Ord,     Y: Ord,

• impl<T, E> Ord for Result<T, E> where     E: Ord,     T: Ord,

• impl<T> Ord for Box<T> where     T: Ord + ?Sized,

• impl<T> Ord for LinkedList<T> where     T: Ord,

• impl<A> Ord for VecDeque<A> where     A: Ord,

• impl<K, V> Ord for BTreeMap<K, V> where     K: Ord,     V: Ord,

• impl<T> Ord for BTreeSet<T> where     T: Ord,

• impl<T> Ord for Vec<T> where     T: Ord,

• impl Ord for String