# [−][src]Struct typenum::uint::UInt

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

`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::{B0, B1, UInt, UTerm};

    type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;

## Methods

### `impl<U: Unsigned, B: Bit> UInt<U, B>`[src]

#### `pub fn new() -> UInt<U, B>`[src]

Instantiates a singleton representing this unsigned integer.

## Trait Implementations

### `impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn>`[src]

#### `type Output = Bn`

### `impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn> where
UInt<Ui, Bi>: Sub<B1>,
Un: GetBit<Sub1<UInt<Ui, Bi>>>,` [src]

#### `type Output = GetBitOut<Un, Sub1<UInt<Ui, Bi>>>`

### `impl<U: Unsigned, B: Bit> NonZero for UInt<U, B>`[src]

### `impl<U: Unsigned, B: Bit> Unsigned for UInt<U, B>`[src]

#### `const U8: u8`[src]

#### `const U16: u16`[src]

#### `const U32: u32`[src]

#### `const U64: u64`[src]

#### `const USIZE: usize`[src]

#### `const I8: i8`[src]

#### `const I16: i16`[src]

#### `const I32: i32`[src]

#### `const I64: i64`[src]

#### `const ISIZE: isize`[src]

#### `fn to_u8() -> u8`[src]

#### `fn to_u16() -> u16`[src]

#### `fn to_u32() -> u32`[src]

#### `fn to_u64() -> u64`[src]

#### `fn to_usize() -> usize`[src]

#### `fn to_i8() -> i8`[src]

#### `fn to_i16() -> i16`[src]

#### `fn to_i32() -> i32`[src]

#### `fn to_i64() -> i64`[src]

#### `fn to_isize() -> isize`[src]

### `impl PowerOfTwo for UInt<UTerm, B1>`[src]

### `impl<U: Unsigned + PowerOfTwo> PowerOfTwo for UInt<U, B0>`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f32`[src]

#### `type Output = f32`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f64`[src]

#### `type Output = f64`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u8`[src]

#### `type Output = u8`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u16`[src]

#### `type Output = u16`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u32`[src]

#### `type Output = u32`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u64`[src]

#### `type Output = u64`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for usize`[src]

#### `type Output = usize`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i8`[src]

#### `type Output = i8`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i16`[src]

#### `type Output = i16`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i32`[src]

#### `type Output = i32`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i64`[src]

#### `type Output = i64`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for isize`[src]

#### `type Output = isize`

The result of the exponentiation.

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<U: Unsigned, B: Bit> Cmp<UTerm> for UInt<U, B>`[src]

Nonzero > Zero

#### `type Output = Greater`

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

### `impl<U: Unsigned, B: Bit> Cmp<UInt<U, B>> for UTerm`[src]

Zero < Nonzero

#### `type Output = Less`

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

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: PrivateCmp<Ur, Equal>,` [src]

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

#### `type Output = PrivateCmpOut<Ul, Ur, Equal>`

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

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: PrivateCmp<Ur, Equal>,` [src]

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

#### `type Output = PrivateCmpOut<Ul, Ur, Equal>`

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

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: PrivateCmp<Ur, Less>,` [src]

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

#### `type Output = PrivateCmpOut<Ul, Ur, Less>`

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

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: PrivateCmp<Ur, Greater>,` [src]

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

#### `type Output = PrivateCmpOut<Ul, Ur, Greater>`

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

### `impl<U: Unsigned, B: Bit> Len for UInt<U, B> where
U: Len,
Length<U>: Add<B1>,
Add1<Length<U>>: Unsigned,` [src]

Length of a bit is 1

#### `type Output = Add1<Length<U>>`

The length as a type-level unsigned integer.

#### `fn len(&self) -> Self::Output`[src]

This function isn't used in this crate, but may be useful for others.

### `impl<Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UTerm`[src]

#### `type Output = UTerm`

The type of the result of the division

#### `fn partial_div(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Method for performing the division

### `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>,` [src]

#### `type Output = Quot<UInt<Ul, Bl>, UInt<Ur, Br>>`

The type of the result of the division

#### `fn partial_div(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Method for performing the division

### `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>>,` [src]

#### `type Output = PrivateMinOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>`

The type of the minimum of `Self` and `Rhs`

#### `fn min(self, rhs: Ur) -> Self::Output`[src]

Method returning the minimum

### `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>>,` [src]

#### `type Output = PrivateMaxOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>`

The type of the maximum of `Self` and `Rhs`

#### `fn max(self, rhs: Ur) -> Self::Output`[src]

Method returning the maximum

### `impl<U: Copy, B: Copy> Copy for UInt<U, B>`[src]

### `impl<U: Debug, B: Debug> Debug for UInt<U, B>`[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl<U: Unsigned, B: Bit> Sub<B0> for UInt<U, B>`[src]

`UInt - B0 = UInt`

#### `type Output = UInt<U, B>`

The resulting type after applying the `-` operator.

#### `fn sub(self, _: B0) -> Self::Output`[src]

Performs the `-` operation.

### `impl<U: Unsigned, B: Bit> Sub<B1> for UInt<UInt<U, B>, B1>`[src]

`UInt<U, B1> - B1 = UInt<U, B0>`

#### `type Output = UInt<UInt<U, B>, B0>`

The resulting type after applying the `-` operator.

#### `fn sub(self, _: B1) -> Self::Output`[src]

Performs the `-` operation.

### `impl Sub<B1> for UInt<UTerm, B1>`[src]

`UInt<UTerm, B1> - B1 = UTerm`

#### `type Output = UTerm`

The resulting type after applying the `-` operator.

#### `fn sub(self, _: B1) -> Self::Output`[src]

Performs the `-` operation.

### `impl<U: Unsigned> Sub<B1> for UInt<U, B0> where
U: Sub<B1>,
Sub1<U>: Unsigned,` [src]

`UInt<U, B0> - B1 = UInt<U - B1, B1>`

#### `type Output = UInt<Sub1<U>, B1>`

The resulting type after applying the `-` operator.

#### `fn sub(self, _: B1) -> Self::Output`[src]

Performs the `-` operation.

### `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,` [src]

Subtracting unsigned integers. We just do our `PrivateSub` and then `Trim` the output.

#### `type Output = TrimOut<PrivateSubOut<UInt<Ul, Bl>, Ur>>`

The resulting type after applying the `-` operator.

#### `fn sub(self, _: Ur) -> Self::Output`[src]

Performs the `-` operation.

### `impl<U: PartialEq, B: PartialEq> PartialEq<UInt<U, B>> for UInt<U, B>`[src]

#### `fn eq(&self, other: &UInt<U, B>) -> bool`[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &UInt<U, B>) -> bool`[src]

This method tests for `!=`.

### `impl<U: Eq, B: Eq> Eq for UInt<U, B>`[src]

### `impl<U: Ord, B: Ord> Ord for UInt<U, B>`[src]

#### `fn cmp(&self, other: &UInt<U, B>) -> Ordering`[src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `fn max(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the minimum of two values. Read more

#### `fn clamp(self, min: Self, max: Self) -> Self`[src]

🔬 This is a nightly-only experimental API. (`clamp`)

Restrict a value to a certain interval. Read more

### `impl<U: PartialOrd, B: PartialOrd> PartialOrd<UInt<U, B>> for UInt<U, B>`[src]

#### `fn partial_cmp(&self, other: &UInt<U, B>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `fn lt(&self, other: &UInt<U, B>) -> bool`[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `fn le(&self, other: &UInt<U, B>) -> bool`[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `fn gt(&self, other: &UInt<U, B>) -> bool`[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `fn ge(&self, other: &UInt<U, B>) -> bool`[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<U: Hash, B: Hash> Hash for UInt<U, B>`[src]

#### `fn hash<__HUB: Hasher>(&self, state: &mut __HUB)`[src]

Feeds this value into the given [`Hasher`]. Read more

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

Feeds a slice of this type into the given [`Hasher`]. Read more

### `impl<U: Unsigned, B: Bit> Add<B0> for UInt<U, B>`[src]

`U + B0 = U`

#### `type Output = UInt<U, B>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: B0) -> Self::Output`[src]

Performs the `+` operation.

### `impl<U: Unsigned> Add<B1> for UInt<U, B0>`[src]

`UInt<U, B0> + B1 = UInt<U + B1>`

#### `type Output = UInt<U, B1>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: B1) -> Self::Output`[src]

Performs the `+` operation.

### `impl<U: Unsigned> Add<B1> for UInt<U, B1> where
U: Add<B1>,
Add1<U>: Unsigned,` [src]

`UInt<U, B1> + B1 = UInt<U + B1, B0>`

#### `type Output = UInt<Add1<U>, B0>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: B1) -> Self::Output`[src]

Performs the `+` operation.

### `impl<U: Unsigned, B: Bit> Add<UTerm> for UInt<U, B>`[src]

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

#### `type Output = UInt<U, B>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: UTerm) -> Self::Output`[src]

Performs the `+` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Add<Ur>,` [src]

`UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>`

#### `type Output = UInt<Sum<Ul, Ur>, B0>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: UInt<Ur, B0>) -> Self::Output`[src]

Performs the `+` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Add<Ur>,` [src]

`UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>`

#### `type Output = UInt<Sum<Ul, Ur>, B1>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: UInt<Ur, B1>) -> Self::Output`[src]

Performs the `+` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Add<Ur>,` [src]

`UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>`

#### `type Output = UInt<Sum<Ul, Ur>, B1>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: UInt<Ur, B0>) -> Self::Output`[src]

Performs the `+` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: Add<Ur>,
Sum<Ul, Ur>: Add<B1>,` [src]

`UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>`

#### `type Output = UInt<Add1<Sum<Ul, Ur>>, B0>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: UInt<Ur, B1>) -> Self::Output`[src]

Performs the `+` operation.

### `impl<U: Unsigned, B: Bit> Mul<B0> for UInt<U, B>`[src]

`UInt * B0 = UTerm`

#### `type Output = UTerm`

The resulting type after applying the `*` operator.

#### `fn mul(self, _: B0) -> Self::Output`[src]

Performs the `*` operation.

### `impl<U: Unsigned, B: Bit> Mul<B1> for UInt<U, B>`[src]

`UInt * B1 = UInt`

#### `type Output = UInt<U, B>`

The resulting type after applying the `*` operator.

#### `fn mul(self, _: B1) -> Self::Output`[src]

Performs the `*` operation.

### `impl<U: Unsigned, B: Bit> Mul<UTerm> for UInt<U, B>`[src]

`UInt<U, B> * UTerm = UTerm`

#### `type Output = UTerm`

The resulting type after applying the `*` operator.

#### `fn mul(self, _: UTerm) -> Self::Output`[src]

Performs the `*` operation.

### `impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B0> where
Ul: Mul<UInt<Ur, B>>,` [src]

`UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>`

#### `type Output = UInt<Prod<Ul, UInt<Ur, B>>, B0>`

The resulting type after applying the `*` operator.

#### `fn mul(self, _: UInt<Ur, B>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B1> where
Ul: Mul<UInt<Ur, B>>,
UInt<Prod<Ul, UInt<Ur, B>>, B0>: Add<UInt<Ur, B>>,` [src]

`UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>`

#### `type Output = Sum<UInt<Prod<Ul, UInt<Ur, B>>, B0>, UInt<Ur, B>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, _: UInt<Ur, B>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UTerm`[src]

#### `type Output = UTerm`

The resulting type after applying the `/` operator.

#### `fn div(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Performs the `/` operation.

### `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>>>>,` [src]

#### `type Output = PrivateDivQuot<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>`

The resulting type after applying the `/` operator.

#### `fn div(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UTerm`[src]

#### `type Output = UTerm`

The resulting type after applying the `%` operator.

#### `fn rem(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Performs the `%` operation.

### `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>>>>,` [src]

#### `type Output = PrivateDivRem<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>`

The resulting type after applying the `%` operator.

#### `fn rem(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Performs the `%` operation.

### `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,` [src]

Anding unsigned integers. We use our `PrivateAnd` operator and then `Trim` the output.

#### `type Output = TrimOut<PrivateAndOut<UInt<Ul, Bl>, Ur>>`

The resulting type after applying the `&` operator.

#### `fn bitand(self, _: Ur) -> Self::Output`[src]

Performs the `&` operation.

### `impl<B: Bit, U: Unsigned> BitOr<UTerm> for UInt<U, B>`[src]

`X | UTerm = X`

#### `type Output = Self`

The resulting type after applying the `|` operator.

#### `fn bitor(self, _: UTerm) -> Self::Output`[src]

Performs the `|` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: BitOr<Ur>,` [src]

`UInt<Ul, B0> | UInt<Ur, B0> = UInt<Ul | Ur, B0>`

#### `type Output = UInt<<Ul as BitOr<Ur>>::Output, B0>`

The resulting type after applying the `|` operator.

#### `fn bitor(self, _: UInt<Ur, B0>) -> Self::Output`[src]

Performs the `|` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: BitOr<Ur>,` [src]

`UInt<Ul, B0> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<Or<Ul, Ur>, B1>`

The resulting type after applying the `|` operator.

#### `fn bitor(self, _: UInt<Ur, B1>) -> Self::Output`[src]

Performs the `|` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: BitOr<Ur>,` [src]

`UInt<Ul, B1> | UInt<Ur, B0> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<Or<Ul, Ur>, B1>`

The resulting type after applying the `|` operator.

#### `fn bitor(self, _: UInt<Ur, B0>) -> Self::Output`[src]

Performs the `|` operation.

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: BitOr<Ur>,` [src]

`UInt<Ul, B1> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<Or<Ul, Ur>, B1>`

The resulting type after applying the `|` operator.

#### `fn bitor(self, _: UInt<Ur, B1>) -> Self::Output`[src]

Performs the `|` operation.

### `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,` [src]

Xoring unsigned integers. We use our `PrivateXor` operator and then `Trim` the output.

#### `type Output = TrimOut<PrivateXorOut<UInt<Ul, Bl>, Ur>>`

The resulting type after applying the `^` operator.

#### `fn bitxor(self, _: Ur) -> Self::Output`[src]

Performs the `^` operation.

### `impl<U: Unsigned, B: Bit> Shl<B0> for UInt<U, B>`[src]

Shifting left any unsigned by a zero bit: `U << B0 = U`

#### `type Output = UInt<U, B>`

The resulting type after applying the `<<` operator.

#### `fn shl(self, _: B0) -> Self::Output`[src]

Performs the `<<` operation.

### `impl<U: Unsigned, B: Bit> Shl<B1> for UInt<U, B>`[src]

Shifting left a `UInt` by a one bit: `UInt<U, B> << B1 = UInt<UInt<U, B>, B0>`

#### `type Output = UInt<UInt<U, B>, B0>`

The resulting type after applying the `<<` operator.

#### `fn shl(self, _: B1) -> Self::Output`[src]

Performs the `<<` operation.

### `impl<U: Unsigned, B: Bit> Shl<UTerm> for UInt<U, B>`[src]

Shifting left `UInt` by `UTerm`: `UInt<U, B> << UTerm = UInt<U, B>`

#### `type Output = UInt<U, B>`

The resulting type after applying the `<<` operator.

#### `fn shl(self, _: UTerm) -> Self::Output`[src]

Performs the `<<` operation.

### `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>>>,` [src]

Shifting left `UInt` by `UInt`: `X << Y` = `UInt(X, B0) << (Y - 1)`

#### `type Output = Shleft<UInt<UInt<U, B>, B0>, Sub1<UInt<Ur, Br>>>`

The resulting type after applying the `<<` operator.

#### `fn shl(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Performs the `<<` operation.

### `impl<U: Unsigned, B: Bit> Shr<UTerm> for UInt<U, B>`[src]

Shifting right `UInt` by `UTerm`: `UInt<U, B> >> UTerm = UInt<U, B>`

#### `type Output = UInt<U, B>`

The resulting type after applying the `>>` operator.

#### `fn shr(self, _: UTerm) -> Self::Output`[src]

Performs the `>>` operation.

### `impl<U: Unsigned, B: Bit> Shr<B0> for UInt<U, B>`[src]

Shifting right any unsigned by a zero bit: `U >> B0 = U`

#### `type Output = UInt<U, B>`

The resulting type after applying the `>>` operator.

#### `fn shr(self, _: B0) -> Self::Output`[src]

Performs the `>>` operation.

### `impl<U: Unsigned, B: Bit> Shr<B1> for UInt<U, B>`[src]

Shifting right a `UInt` by a 1 bit: `UInt<U, B> >> B1 = U`

#### `type Output = U`

The resulting type after applying the `>>` operator.

#### `fn shr(self, _: B1) -> Self::Output`[src]

Performs the `>>` operation.

### `impl<U: Unsigned, 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>>>,` [src]

Shifting right `UInt` by `UInt`: `UInt(U, B) >> Y` = `U >> (Y - 1)`

#### `type Output = Shright<U, Sub1<UInt<Ur, Br>>>`

The resulting type after applying the `>>` operator.

#### `fn shr(self, _: UInt<Ur, Br>) -> Self::Output`[src]

Performs the `>>` operation.

### `impl<U: Clone, B: Clone> Clone for UInt<U, B>`[src]

#### `fn clone(&self) -> UInt<U, B>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

### `impl<U: Default, B: Default> Default for UInt<U, B>`[src]

#### `fn default() -> UInt<U, B>`[src]

Returns the "default value" for a type. Read more

## Auto Trait Implementations

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

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

## Blanket Implementations

### `impl<N, I, B> SetBit<I, B> for N where
N: PrivateSetBit<I, B>,
<N as PrivateSetBit<I, B>>::Output: Trim,` [src]

#### `type Output = <<N as PrivateSetBit<I, B>>::Output as Trim>::Output`

### `impl<T> Same<T> for T`[src]

#### `type Output = T`

Should always be `Self`

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

#### `type Output = <X as PrivatePow<UInt<UTerm, B1>, N>>::Output`

The result of the exponentiation.

#### `fn powi(Self, N) -> <X as Pow<N>>::Output`[src]

This function isn't used in this crate, but may be useful for others. It is implemented for primitives. Read more

### `impl<M, N> PartialDiv<N> for M where
M: Integer + Div<N> + Rem<N, Output = Z0>,` [src]

#### `type Output = <M as Div<N>>::Output`

The type of the result of the division

#### `fn partial_div(Self, N) -> <M as PartialDiv<N>>::Output`[src]

Method for performing the division

### `impl<A, B> IsLess<B> for A where
A: Cmp<B> + IsLessPrivate<B, <A as Cmp<B>>::Output>,` [src]

#### `type Output = <A as IsLessPrivate<B, <A as Cmp<B>>::Output>>::Output`

The type representing either `True` or `False`

#### `fn is_less(Self, B) -> <A as IsLess<B>>::Output`[src]

Method returning `True` or `False`.

### `impl<A, B> IsEqual<B> for A where
A: Cmp<B> + IsEqualPrivate<B, <A as Cmp<B>>::Output>,` [src]

#### `type Output = <A as IsEqualPrivate<B, <A as Cmp<B>>::Output>>::Output`

The type representing either `True` or `False`

#### `fn is_equal(Self, B) -> <A as IsEqual<B>>::Output`[src]

Method returning `True` or `False`.

### `impl<A, B> IsGreater<B> for A where
A: Cmp<B> + IsGreaterPrivate<B, <A as Cmp<B>>::Output>,` [src]

#### `type Output = <A as IsGreaterPrivate<B, <A as Cmp<B>>::Output>>::Output`

The type representing either `True` or `False`

#### `fn is_greater(Self, B) -> <A as IsGreater<B>>::Output`[src]

Method returning `True` or `False`.

### `impl<A, B> IsLessOrEqual<B> for A where
A: Cmp<B> + IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>,` [src]

#### `type Output = <A as IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output`

The type representing either `True` or `False`

#### `fn is_less_or_equal(Self, B) -> <A as IsLessOrEqual<B>>::Output`[src]

Method returning `True` or `False`.

### `impl<A, B> IsNotEqual<B> for A where
A: Cmp<B> + IsNotEqualPrivate<B, <A as Cmp<B>>::Output>,` [src]

#### `type Output = <A as IsNotEqualPrivate<B, <A as Cmp<B>>::Output>>::Output`

The type representing either `True` or `False`

#### `fn is_not_equal(Self, B) -> <A as IsNotEqual<B>>::Output`[src]

Method returning `True` or `False`.

### `impl<A, B> IsGreaterOrEqual<B> for A where
A: Cmp<B> + IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>,` [src]

#### `type Output = <A as IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output`

The type representing either `True` or `False`

#### `fn is_greater_or_equal(Self, B) -> <A as IsGreaterOrEqual<B>>::Output`[src]

Method returning `True` or `False`.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)