Struct UInt

pub struct UInt<U, B> { /* private fields */ }

UInt is defined recursively, where B is the least significant bit and U is the rest of the number. Conceptually, U should be bound by the trait Unsigned and B should be bound by the trait Bit, but enforcing these bounds causes linear instead of logrithmic scaling in some places, so they are left off for now. They may be enforced in future.

In order to keep numbers unique, leading zeros are not allowed, so UInt<UTerm, B0> is forbidden.

Example

use typenum::{UInt, UTerm, B0, B1};

# #[allow(dead_code)]
type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;

Implementations

impl<U: Unsigned, B: Bit> UInt<U, B>

fn new() -> UInt<U, B>

Instantiates a singleton representing this unsigned integer.

Trait Implementations

impl Binary for UInt<UTerm, B0>

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

impl Binary for UInt<UTerm, B1>

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

impl PowerOfTwo for UInt<UTerm, B1>

impl Sub<B1> for UInt<UTerm, B1>

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

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

type Output = UInt<U, B>;
fn bitor(self, UTerm) -> Self::Output

impl<U> Add<B1> for UInt<U, B1> where U: Add<B1> + Unsigned, Add1<U>: Unsigned,

type Output = UInt<<U as Add<B1>>::Output, B0>;
fn add(self, B1) -> Self::Output

impl<U> Sub<B1> for UInt<U, B0> where U: Sub<B1> + Unsigned, Sub1<U>: Unsigned,

type Output = UInt<<U as Sub<B1>>::Output, B1>;
fn sub(self, B1) -> Self::Output

impl<U, B> ToInt<i16> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<i32> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<i64> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<i8> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<isize> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<u16> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<u32> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<u64> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<u8> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B> ToInt<usize> for UInt<U, B> where U: Unsigned, B: Bit,

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

impl<U, B, Ur> Max<Ur> for UInt<U, B> where U: Unsigned, B: Bit, Ur: Unsigned, UInt<U, B>: Cmp<Ur> + PrivateMax<Ur, Compare<UInt<U, B>, Ur>>,

type Output = <UInt<U, B> as PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>>::Output;
fn max(self, rhs: Ur) -> Self::Output

impl<U, B, Ur> Min<Ur> for UInt<U, B> where U: Unsigned, B: Bit, Ur: Unsigned, UInt<U, B>: Cmp<Ur> + PrivateMin<Ur, Compare<UInt<U, B>, Ur>>,

type Output = <UInt<U, B> as PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>>::Output;
fn min(self, rhs: Ur) -> Self::Output

impl<U, B: Bit> Len for UInt<U, B> where U: Len + Unsigned, Length<U>: Add<B1>, Add1<Length<U>>: Unsigned,

type Output = <<U as Len>::Output as Add<B1>>::Output;
fn len(&self) -> Self::Output

impl<U, B: Bit, Ur: Unsigned, Br: Bit> Shr<UInt<Ur, Br>> for UInt<U, B> where UInt<Ur, Br>: Sub<B1>, U: Shr<Sub1<UInt<Ur, Br>>> + Unsigned,

type Output = <U as Shr<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output;
fn shr(self, rhs: UInt<Ur, Br>) -> Self::Output

impl<U: Clone, B: Clone> Clone for UInt<U, B>

fn clone(&self) -> Self

impl<U: Copy, B: Copy> Copy for UInt<U, B>

impl<U: Debug, B: Debug> Debug for UInt<U, B>

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

impl<U: Default, B: Default> Default for UInt<U, B>

fn default() -> Self

impl<U: Eq, B: Eq> Eq for UInt<U, B>

impl<U: Hash, B: Hash> Hash for UInt<U, B>

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

impl<U: Ord, B: Ord> Ord for UInt<U, B>

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

impl<U: PartialEq, B: PartialEq> PartialEq for UInt<U, B>

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

impl<U: PartialEq, B: PartialEq> StructuralPartialEq for UInt<U, B>

impl<U: PartialOrd, B: PartialOrd> PartialOrd for UInt<U, B>

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

impl<U: Unsigned + PowerOfTwo> PowerOfTwo for UInt<U, B0>

impl<U: Unsigned> Add<B1> for UInt<U, B0>

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

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

type Output = UInt<U, B>;
fn add(self, B0) -> Self::Output

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

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

impl<U: Unsigned, B: Bit> Binary for UInt<UInt<U, B>, B0> where UInt<U, B>: Binary,

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

impl<U: Unsigned, B: Bit> Binary for UInt<UInt<U, B>, B1> where UInt<U, B>: Binary,

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

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

type Output = Greater;

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

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

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

type Output = UInt<U, B>;
fn mul(self, B1) -> Self::Output

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

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

impl<U: Unsigned, B: Bit> NonZero for UInt<U, B>

impl<U: Unsigned, B: Bit> Shl<B0> for UInt<U, B>

type Output = UInt<U, B>;
fn shl(self, B0) -> Self::Output

impl<U: Unsigned, B: Bit> Shl<B1> for UInt<U, B>

type Output = UInt<UInt<U, B>, B0>;
fn shl(self, B1) -> Self::Output

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

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

impl<U: Unsigned, B: Bit> Shr<B0> for UInt<U, B>

type Output = UInt<U, B>;
fn shr(self, B0) -> Self::Output

impl<U: Unsigned, B: Bit> Shr<B1> for UInt<U, B>

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

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

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

impl<U: Unsigned, B: Bit> Sub<B0> for UInt<U, B>

type Output = UInt<U, B>;
fn sub(self, B0) -> Self::Output

impl<U: Unsigned, B: Bit> Sub<B1> for UInt<UInt<U, B>, B1>

type Output = UInt<UInt<U, B>, B0>;
fn sub(self, B1) -> Self::Output

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

const U8: u8 = _;
const U16: u16 = _;
const U32: u32 = _;
const U64: u64 = _;
const USIZE: usize = _;
const I8: i8 = _;
const I16: i16 = _;
const I32: i32 = _;
const I64: i64 = _;
const ISIZE: isize = _;
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<U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit> Shl<UInt<Ur, Br>> for UInt<U, B> where UInt<Ur, Br>: Sub<B1>, UInt<UInt<U, B>, B0>: Shl<Sub1<UInt<Ur, Br>>>,

type Output = <UInt<UInt<U, B>, B0> as Shl<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output;
fn shl(self, rhs: UInt<Ur, Br>) -> Self::Output

impl<Ul, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B0> where Ul: Mul<UInt<Ur, B>> + Unsigned,

type Output = UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0>;
fn mul(self, rhs: UInt<Ur, B>) -> Self::Output

impl<Ul, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B1> where Ul: Mul<UInt<Ur, B>> + Unsigned, UInt<Prod<Ul, UInt<Ur, B>>, B0>: Add<UInt<Ur, B>>,

type Output = <UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0> as Add<UInt<Ur, B>>>::Output;
fn mul(self, rhs: UInt<Ur, B>) -> Self::Output

impl<Ul, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B0> where Ul: Add<Ur> + Unsigned,

type Output = UInt<<Ul as Add<Ur>>::Output, B0>;
fn add(self, rhs: UInt<Ur, B0>) -> Self::Output

impl<Ul, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B1> where Ul: Add<Ur> + Unsigned,

type Output = UInt<<Ul as Add<Ur>>::Output, B1>;
fn add(self, rhs: UInt<Ur, B0>) -> Self::Output

impl<Ul, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B0> where Ul: Add<Ur> + Unsigned,

type Output = UInt<<Ul as Add<Ur>>::Output, B1>;
fn add(self, rhs: UInt<Ur, B1>) -> Self::Output

impl<Ul, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B1> where Ul: Add<Ur> + Unsigned, Sum<Ul, Ur>: Add<B1>,

type Output = UInt<<<Ul as Add<Ur>>::Output as Add<B1>>::Output, B0>;
fn add(self, rhs: UInt<Ur, B1>) -> Self::Output

impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B0> where Ul: BitOr<Ur> + Unsigned,

type Output = UInt<<Ul as BitOr<Ur>>::Output, B0>;
fn bitor(self, rhs: UInt<Ur, B0>) -> Self::Output

impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B1> where Ul: BitOr<Ur> + Unsigned,

type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>;
fn bitor(self, rhs: UInt<Ur, B0>) -> Self::Output

impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B0> where Ul: BitOr<Ur> + Unsigned,

type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>;
fn bitor(self, rhs: UInt<Ur, B1>) -> Self::Output

impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B1> where Ul: BitOr<Ur> + Unsigned,

type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>;
fn bitor(self, rhs: UInt<Ur, B1>) -> Self::Output

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

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,

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,

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,

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

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitAnd<Ur> for UInt<Ul, Bl> where UInt<Ul, Bl>: PrivateAnd<Ur>, PrivateAndOut<UInt<Ul, Bl>, Ur>: Trim,

type Output = <<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output as Trim>::Output;
fn bitand(self, rhs: Ur) -> Self::Output

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitXor<Ur> for UInt<Ul, Bl> where UInt<Ul, Bl>: PrivateXor<Ur>, PrivateXorOut<UInt<Ul, Bl>, Ur>: Trim,

type Output = <<UInt<Ul, Bl> as PrivateXor<Ur>>::Output as Trim>::Output;
fn bitxor(self, rhs: Ur) -> Self::Output

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Sub<Ur> for UInt<Ul, Bl> where UInt<Ul, Bl>: PrivateSub<Ur>, PrivateSubOut<UInt<Ul, Bl>, Ur>: Trim,

type Output = <<UInt<Ul, Bl> as PrivateSub<Ur>>::Output as Trim>::Output;
fn sub(self, rhs: Ur) -> Self::Output

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UInt<Ul, Bl> where UInt<Ul, Bl>: Len, Length<UInt<Ul, Bl>>: Sub<B1>, (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>,

type Output = <() as PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>>::Quotient;
fn div(self, rhs: UInt<Ur, Br>) -> Self::Output

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl> where UInt<Ul, Bl>: Div<UInt<Ur, Br>> + Rem<UInt<Ur, Br>, Output = U0>,

type Output = <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output;
fn partial_div(self, rhs: UInt<Ur, Br>) -> Self::Output

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UInt<Ul, Bl> where UInt<Ul, Bl>: Len, Length<UInt<Ul, Bl>>: Sub<B1>, (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>,

type Output = <() as PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>>::Remainder;
fn rem(self, rhs: UInt<Ur, Br>) -> Self::Output

impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn> where Bn: Copy,

type Output = Bn;

impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn> where UInt<Ui, Bi>: Copy + Sub<B1>, Un: GetBit<Sub1<UInt<Ui, Bi>>>,

type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output;

impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B0> where Xp: Gcd<Yp>, UInt<Xp, B0>: NonZero, UInt<Yp, B0>: NonZero,

type Output = UInt<<Xp as Gcd<Yp>>::Output, B0>;

impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B1> where UInt<Xp, B1>: Gcd<Yp>, UInt<Yp, B0>: NonZero,

type Output = <UInt<Xp, B1> as Gcd<Yp>>::Output;

impl<Xp, Yp> Gcd<UInt<Yp, B1>> for UInt<Xp, B0> where Xp: Gcd<UInt<Yp, B1>>, UInt<Xp, B0>: NonZero,

type Output = <Xp as Gcd<UInt<Yp, B1>>>::Output;

impl<Xp, Yp> Gcd<UInt<Yp, B1>> for UInt<Xp, B1> where UInt<Xp, B1>: Max<UInt<Yp, B1>> + Min<UInt<Yp, B1>>, UInt<Yp, B1>: Max<UInt<Xp, B1>> + Min<UInt<Xp, B1>>, Maximum<UInt<Xp, B1>, UInt<Yp, B1>>: Sub<Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>, Diff<Maximum<UInt<Xp, B1>, UInt<Yp, B1>>, Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>: Gcd<Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>,

type Output = <<<UInt<Xp, B1> as Max<UInt<Yp, B1>>>::Output as Sub<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>>::Output as Gcd<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>>::Output;

Auto Trait Implementations

impl<U, B> Freeze for UInt<U, B> where U: Freeze, B: Freeze,

impl<U, B> RefUnwindSafe for UInt<U, B> where U: RefUnwindSafe, B: RefUnwindSafe,

impl<U, B> Send for UInt<U, B> where U: Send, B: Send,

impl<U, B> Sync for UInt<U, B> where U: Sync, B: Sync,

impl<U, B> Unpin for UInt<U, B> where U: Unpin, B: Unpin,

impl<U, B> UnsafeUnpin for UInt<U, B> where U: UnsafeUnpin, B: UnsafeUnpin,

impl<U, B> UnwindSafe for UInt<U, B> where U: UnwindSafe, B: UnwindSafe,

Blanket Implementations

impl<A, B> IsEqual<B> for UInt<U, B> 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 UInt<U, B> 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 UInt<U, B> 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 UInt<U, B> 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 UInt<U, B> 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 UInt<U, B> 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> Logarithm2 for UInt<U, B> where N: PrivateLogarithm2,

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

impl<N> SquareRoot for UInt<U, B> where N: PrivateSquareRoot,

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

impl<N, I, B> SetBit<I, B> for UInt<U, B> 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 UInt<U, B> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for UInt<U, B> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for UInt<U, B> where T: ?Sized,

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

impl<T> CloneToUninit for UInt<U, B> where T: Clone,

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

impl<T> From<T> for UInt<U, B>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Same for UInt<U, B>

type Output = T;

impl<T, U> Into<U> for UInt<U, B> 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 UInt<U, B> where U: Into<T>,

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

impl<T, U> TryInto<U> for UInt<U, B> where U: TryFrom<T>,

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

impl<X> Gcd<UTerm> for UInt<U, B> where X: Unsigned + NonZero,

type Output = X;

impl<X, N> Pow<N> for UInt<U, B> 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