Trait typenum::type_operators::Cmp

pub trait Cmp<Rhs = Self> {
    type 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);

Associated Types

type Output

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

Implementors

impl Cmp<B0> for B0

type Output = Equal

impl Cmp<B0> for B1

type Output = Greater

impl Cmp<B1> for B0

type Output = Less

impl Cmp<B1> for B1

type Output = Equal

impl Cmp<Z0> for Z0

0 == 0

type Output = Equal

impl Cmp<UTerm> for UTerm

Zero == Zero

type Output = Equal

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 PInt<U>

X > 0

type Output = Greater

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

-X < 0

type Output = Less

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: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B0> where     Ul: PrivateCmp<Ur, Equal>,

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

type Output = PrivateCmpOut<Ul, Ur, Equal>

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

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

type Output = PrivateCmpOut<Ul, Ur, Greater>

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

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

type Output = PrivateCmpOut<Ul, Ur, Less>

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

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

type Output = PrivateCmpOut<Ul, Ur, Equal>