Trait Cmp 

pub trait Cmp<Rhs = Self> {
    type Output;

    // Required method
    #[doc(hidden)] fn compare<IM: InternalMarker>(
        &self,
        _: &Rhs,
    ) -> Self::Output;
}

A type operator for comparing Self and Rhs. It provides a similar functionality to the function core::cmp::Ord::cmp but for types.

Example

use typenum::{Cmp, Ord, N3, P2, P5};
use std::cmp::Ordering;

assert_eq!(<P2 as Cmp<N3>>::Output::to_ordering(), Ordering::Greater);
assert_eq!(<P2 as Cmp<P2>>::Output::to_ordering(), Ordering::Equal);
assert_eq!(<P2 as Cmp<P5>>::Output::to_ordering(), Ordering::Less);

Required Associated Types

type Output

The result of the comparison. It should only ever be one of Greater, Less, or Equal.

Required Methods

#[doc(hidden)] fn compare<IM: InternalMarker>(&self, _: &Rhs) -> Self::Output

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Cmp for B0

type Output = Equal

impl Cmp for B1

type Output = Equal

impl Cmp for Z0

0 == 0

type Output = Equal

impl Cmp for UTerm

Zero == Zero

type Output = Equal

impl Cmp<B0> for B1

type Output = Greater

impl Cmp<B1> for B0

type Output = Less

impl<Nl: Unsigned + NonZero, Nr: Cmp<Nl> + Unsigned + NonZero> Cmp<NInt<Nr>> for NInt<Nl>

-X <==> -Y

type Output = <Nr as Cmp<Nl>>::Output

impl<P: Unsigned + NonZero, N: Unsigned + NonZero> Cmp<NInt<N>> for PInt<P>

X > - Y

type Output = Greater

impl<P: Unsigned + NonZero, N: Unsigned + NonZero> Cmp<PInt<P>> for NInt<N>

-X < Y

type Output = Less

impl<Pl: Cmp<Pr> + Unsigned + NonZero, Pr: Unsigned + NonZero> Cmp<PInt<Pr>> for PInt<Pl>

X <==> Y

type Output = <Pl as Cmp<Pr>>::Output

impl<U: Unsigned + NonZero> Cmp<NInt<U>> for Z0

0 > -X

type Output = Greater

impl<U: Unsigned + NonZero> Cmp<PInt<U>> for Z0

0 < X

type Output = Less

impl<U: Unsigned + NonZero> Cmp<Z0> for NInt<U>

-X < 0

type Output = Less

impl<U: Unsigned + NonZero> Cmp<Z0> for PInt<U>

X > 0

type Output = Greater

impl<U: Unsigned, B: Bit> Cmp<UInt<U, B>> for UTerm

Zero < Nonzero

type Output = Less

impl<U: Unsigned, B: Bit> Cmp<UTerm> for UInt<U, B>

Nonzero > Zero

type Output = Greater

impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B0>

where Ul: PrivateCmp<Ur, Equal> + Unsigned,

UInt<Ul, B0> cmp with UInt<Ur, B0>: SoFar is Equal

type Output = <Ul as PrivateCmp<Ur, Equal>>::Output

impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B1>

where Ul: PrivateCmp<Ur, Greater> + Unsigned,

UInt<Ul, B1> cmp with UInt<Ur, B0>: SoFar is Greater

type Output = <Ul as PrivateCmp<Ur, Greater>>::Output

impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B0>

where Ul: PrivateCmp<Ur, Less> + Unsigned,

UInt<Ul, B0> cmp with UInt<Ur, B1>: SoFar is Less

type Output = <Ul as PrivateCmp<Ur, Less>>::Output

impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B1>

where Ul: PrivateCmp<Ur, Equal> + Unsigned,

UInt<Ul, B1> cmp with UInt<Ur, B1>: SoFar is Equal

type Output = <Ul as PrivateCmp<Ur, Equal>>::Output