Enum typenum::uint::UTerm

pub enum UTerm {}

The terminating type for UInt; it always comes after the most significant bit. UTerm by itself represents zero, which is aliased to U0.

Trait Implementations

impl PartialEq for UTerm

fn eq(&self, _: &Self) -> bool

fn ne(&self, other: &Rhs) -> bool

impl Eq for UTerm

impl PartialOrd for UTerm

fn partial_cmp(&self, _: &Self) -> 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

impl Ord for UTerm

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

impl Clone for UTerm

fn clone(&self) -> Self

fn clone_from(&mut self, source: &Self)

impl Copy for UTerm

impl Hash for UTerm

fn hash<H>(&self, _: &mut H) where H: Hasher

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

impl Default for UTerm

fn default() -> Self

impl Debug for UTerm

fn fmt(&self, _: &mut Formatter) -> Result<(), Error>

impl Unsigned for UTerm

fn to_u8() -> u8

fn to_u16() -> u16

fn to_u32() -> u32

fn to_u64() -> u64

fn to_usize() -> usize

fn to_i8() -> i8

fn to_i16() -> i16

fn to_i32() -> i32

fn to_i64() -> i64

fn to_isize() -> isize

impl Add<B0> for UTerm

UTerm + B0 = UTerm

type Output = UTerm

fn add(self, _: B0) -> Self::Output

impl Add<B1> for UTerm

UTerm + B1 = UInt<UTerm, B1>

type Output = UInt<UTerm, B1>

fn add(self, _: B1) -> Self::Output

impl Add<UTerm> for UTerm

UTerm + UTerm = UTerm

type Output = UTerm

fn add(self, _: UTerm) -> Self::Output

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

UTerm + UInt<U, B> = UInt<U, B>

type Output = UInt<U, B>

fn add(self, _: UInt<U, B>) -> Self::Output

impl Sub<B0> for UTerm

UTerm - B0 = Term

type Output = UTerm

fn sub(self, _: B0) -> Self::Output

impl Sub<UTerm> for UTerm

UTerm - UTerm = UTerm

type Output = UTerm

fn sub(self, _: UTerm) -> Self::Output

impl<Ur: Unsigned> BitAnd<Ur> for UTerm

type Output = UTerm

fn bitand(self, _: Ur) -> Self::Output

impl<U: Unsigned> BitOr<U> for UTerm

UTerm | X = X

type Output = U

fn bitor(self, _: U) -> Self::Output

impl<Ur: Unsigned> BitXor<Ur> for UTerm

0 ^ X = X

type Output = Ur

fn bitxor(self, _: Ur) -> Self::Output

impl<U: Unsigned> Shl<U> for UTerm

Shifting left UTerm by an unsigned integer: UTerm << U = UTerm

type Output = UTerm

fn shl(self, _: U) -> Self::Output

impl Shl<B0> for UTerm

Shifting UTerm by a zero bit: UTerm << B0 = UTerm

type Output = UTerm

fn shl(self, _: B0) -> Self::Output

impl Shl<B1> for UTerm

Shifting left a UTerm by a 1 bit: UTerm << B1 = UTerm

type Output = UTerm

fn shl(self, _: B1) -> Self::Output

impl<U: Unsigned> Shr<U> for UTerm

Shifting right a UTerm by an unsigned integer: UTerm >> U = UTerm

type Output = UTerm

fn shr(self, _: U) -> Self::Output

impl Shr<B0> for UTerm

Shifting right UTerm by a zero bit: UTerm >> B0 = UTerm

type Output = UTerm

fn shr(self, _: B0) -> Self::Output

impl Shr<B1> for UTerm

Shifting right a UTerm by a 1 bit: UTerm >> B1 = UTerm

type Output = UTerm

fn shr(self, _: B1) -> Self::Output

impl<B: Bit> Mul<B> for UTerm

UTerm * B = UTerm

type Output = UTerm

fn mul(self, _: B) -> Self::Output

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

UTerm * UInt<U, B> = UTerm

type Output = UTerm

fn mul(self, _: UInt<U, B>) -> Self::Output

impl Mul<UTerm> for UTerm

UTerm * UTerm = UTerm

type Output = UTerm

fn mul(self, _: UTerm) -> Self::Output

impl Cmp<UTerm> for UTerm

Zero == Zero

type Output = Equal

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

Zero < Nonzero

type Output = Less

impl<Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UTerm

type Output = UTerm

fn div(self, _: UInt<Ur, Br>) -> Self::Output

impl<Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UTerm

type Output = UTerm

fn rem(self, _: UInt<Ur, Br>) -> Self::Output