Struct `UTerm`

pub struct UTerm;

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

Implementations

`impl UTerm`

fn new() -> UTerm: Instantiates a singleton representing this unsigned integer.

Trait Implementations

`impl Add<B0> for UTerm`

type Output = UTerm;
fn add(self, B0) -> Self::Output

`impl Add<B1> for UTerm`

type Output = UInt<UTerm, B1>;
fn add(self, B1) -> Self::Output

`impl Binary for UTerm`

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

`impl Clone for UTerm`

fn clone(&self) -> Self

`impl Cmp for UTerm`

type Output = Equal;

`impl Copy for UTerm`

`impl Debug for UTerm`

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

`impl Default for UTerm`

fn default() -> Self

`impl Eq for UTerm`

`impl Hash for UTerm`

fn hash<__H: Hasher>(&self, state: &mut __H)

`impl Len for UTerm`

type Output = UTerm;
fn len(&self) -> Self::Output

`impl Mul<B0> for UTerm`

type Output = UTerm;
fn mul(self, B0) -> Self::Output

`impl Mul<B1> for UTerm`

type Output = UTerm;
fn mul(self, B1) -> Self::Output

`impl Ord for UTerm`

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

`impl PartialEq for UTerm`

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

`impl PartialOrd for UTerm`

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

`impl Shl<B0> for UTerm`

type Output = UTerm;
fn shl(self, B0) -> Self::Output

`impl Shl<B1> for UTerm`

type Output = UTerm;
fn shl(self, B1) -> Self::Output

`impl Shr<B0> for UTerm`

type Output = UTerm;
fn shr(self, B0) -> Self::Output

`impl Shr<B1> for UTerm`

type Output = UTerm;
fn shr(self, B1) -> Self::Output

`impl StructuralPartialEq for UTerm`

`impl Sub for UTerm`

type Output = UTerm;
fn sub(self, UTerm) -> Self::Output

`impl Sub<B0> for UTerm`

type Output = UTerm;
fn sub(self, B0) -> Self::Output

`impl ToInt<i16> for UTerm`

fn to_int() -> i16
const INT: i16 = Self::I16;

`impl ToInt<i32> for UTerm`

fn to_int() -> i32
const INT: i32 = Self::I32;

`impl ToInt<i64> for UTerm`

fn to_int() -> i64
const INT: i64 = Self::I64;

`impl ToInt<i8> for UTerm`

fn to_int() -> i8
const INT: i8 = Self::I8;

`impl ToInt<isize> for UTerm`

fn to_int() -> isize
const INT: isize = Self::ISIZE;

`impl ToInt<u16> for UTerm`

fn to_int() -> u16
const INT: u16 = Self::U16;

`impl ToInt<u32> for UTerm`

fn to_int() -> u32
const INT: u32 = Self::U32;

`impl ToInt<u64> for UTerm`

fn to_int() -> u64
const INT: u64 = Self::U64;

`impl ToInt<u8> for UTerm`

fn to_int() -> u8
const INT: u8 = Self::U8;

`impl ToInt<usize> for UTerm`

fn to_int() -> usize
const INT: usize = Self::USIZE;

`impl Unsigned for UTerm`

const U8: u8 = 0;
const U16: u16 = 0;
const U32: u32 = 0;
const U64: u64 = 0;
const USIZE: usize = 0;
const I8: i8 = 0;
const I16: i16 = 0;
const I32: i32 = 0;
const I64: i64 = 0;
const ISIZE: isize = 0;
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 Zero for UTerm`

`impl<I> GetBit<I> for UTerm`

type Output = B0;

`impl<U> Max<U> for UTerm where U: Unsigned,`

type Output = U;
fn max(self, rhs: U) -> Self::Output

`impl<U> Min<U> for UTerm where U: Unsigned,`

type Output = UTerm;
fn min(self, U) -> Self::Output

`impl<U: Unsigned> Add<U> for UTerm`

type Output = U;
fn add(self, rhs: U) -> Self::Output

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

type Output = U;
fn bitor(self, rhs: U) -> Self::Output

`impl<U: Unsigned> Mul<U> for UTerm`

type Output = UTerm;
fn mul(self, U) -> Self::Output

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

type Output = UTerm;
fn shl(self, U) -> Self::Output

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

type Output = UTerm;
fn shr(self, U) -> Self::Output

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

type Output = Less;

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

type Output = UTerm;
fn bitand(self, Ur) -> Self::Output

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

type Output = Ur;
fn bitxor(self, rhs: Ur) -> Self::Output

`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> PartialDiv<UInt<Ur, Br>> for UTerm`

type Output = UTerm;
fn partial_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

Auto Trait Implementations

`impl Freeze for UTerm`

`impl RefUnwindSafe for UTerm`

`impl Send for UTerm`

`impl Sync for UTerm`

`impl Unpin for UTerm`

`impl UnsafeUnpin for UTerm`

`impl UnwindSafe for UTerm`

Blanket Implementations

`impl<A, B> IsEqual<B> for UTerm where A: Cmp<B> + IsEqualPrivate<B, <A as Cmp<B>>::Output>,`

type Output = <A as IsEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_equal(self, rhs: B) -> <A as IsEqual<B>>::Output

`impl<A, B> IsGreater<B> for UTerm where A: Cmp<B> + IsGreaterPrivate<B, <A as Cmp<B>>::Output>,`

type Output = <A as IsGreaterPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_greater(self, rhs: B) -> <A as IsGreater<B>>::Output

`impl<A, B> IsGreaterOrEqual<B> for UTerm where A: Cmp<B> + IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>,`

type Output = <A as IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_greater_or_equal(self, rhs: B) -> <A as IsGreaterOrEqual<B>>::Output

`impl<A, B> IsLess<B> for UTerm where A: Cmp<B> + IsLessPrivate<B, <A as Cmp<B>>::Output>,`

type Output = <A as IsLessPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_less(self, rhs: B) -> <A as IsLess<B>>::Output

`impl<A, B> IsLessOrEqual<B> for UTerm where A: Cmp<B> + IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>,`

type Output = <A as IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_less_or_equal(self, rhs: B) -> <A as IsLessOrEqual<B>>::Output

`impl<A, B> IsNotEqual<B> for UTerm where A: Cmp<B> + IsNotEqualPrivate<B, <A as Cmp<B>>::Output>,`

type Output = <A as IsNotEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_not_equal(self, rhs: B) -> <A as IsNotEqual<B>>::Output

`impl<N> SquareRoot for UTerm where N: PrivateSquareRoot,`

type Output = <N as PrivateSquareRoot>::Output;

`impl<N, I, B> SetBit<I, B> for UTerm where N: PrivateSetBit<I, B>, <N as PrivateSetBit<I, B>>::Output: Trim,`

type Output = <<N as PrivateSetBit<I, B>>::Output as Trim>::Output;
fn set_bit<IM>(self, i: I, b: B) -> <N as SetBit<I, B>>::Output where IM: InternalMarker,

`impl<T> Any for UTerm where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for UTerm where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for UTerm where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for UTerm where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for UTerm`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Same for UTerm`

type Output = T;

`impl<T, U> Into<U> for UTerm where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom<U> for UTerm where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto<U> for UTerm where U: TryFrom<T>,`

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<X, N> Pow<N> for UTerm where X: Unsigned + PrivatePow<UInt<UTerm, B1>, N>, N: Unsigned,`

type Output = <X as PrivatePow<UInt<UTerm, B1>, N>>::Output;
fn powi(self, n: N) -> <X as Pow<N>>::Output