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

`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, Unsigned};

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

## Methods

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

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

Instantiates a singleton representing this unsigned integer.

## Trait Implementations

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

#### `fn eq(&self, __arg_0: &UInt<U, B>) -> bool`

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

#### `fn ne(&self, __arg_0: &UInt<U, B>) -> bool`

This method tests for `!=`.

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

#### `fn cmp(&self, __arg_0: &UInt<U, B>) -> Ordering`

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

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

#### `fn partial_cmp(&self, __arg_0: &UInt<U, B>) -> Option<Ordering>`

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

#### `fn lt(&self, __arg_0: &UInt<U, B>) -> bool`

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

#### `fn le(&self, __arg_0: &UInt<U, B>) -> bool`

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

#### `fn gt(&self, __arg_0: &UInt<U, B>) -> bool`

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

#### `fn ge(&self, __arg_0: &UInt<U, B>) -> bool`

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

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

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

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`. Read more

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

#### `fn hash<__HUB: Hasher>(&self, __arg_0: &mut __HUB)`

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.

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

#### `fn fmt(&self, __arg_0: &mut Formatter) -> Result`

Formats the value using the given formatter.

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

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

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

### `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`

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

### `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`

The method for the `+` operator

### `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`

The method for the `+` operator

### `impl<U: Unsigned> Add<B1> for UInt<U, B1> where U: Add<B1>, Sum<U, B1>: 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`

The method for the `+` operator

### `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`

The method for the `+` operator

### `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`

The method for the `+` operator

### `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`

The method for the `+` operator

### `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`

The method for the `+` operator

### `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`

The method for the `+` operator

### `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`

The method for the `-` operator

### `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`

The method for the `-` operator

### `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`

The method for the `-` operator

### `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`

The method for the `-` operator

### `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`

The method for the `-` operator

### `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`

The method for the `&` operator

### `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`

The method for the `|` operator

### `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::Output, B0>`

The resulting type after applying the `|` operator

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

The method for the `|` operator

### `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`

The method for the `|` operator

### `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`

The method for the `|` operator

### `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`

The method for the `|` operator

### `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`

The method for the `^` operator

### `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`

The method for the `<<` operator

### `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`

The method for the `<<` operator

### `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`

The method for the `<<` operator

### `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`

The method for the `<<` operator

### `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`

The method for the `>>` operator

### `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`

The method for the `>>` operator

### `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`

The method for the `>>` operator

### `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`

The method for the `>>` operator

### `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`

The method for the `*` operator

### `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`

The method for the `*` operator

### `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`

The method for the `*` operator

### `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`

The method for the `*` operator

### `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`

The method for the `*` operator

### `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<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<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Div<Ur> for UInt<Ul, Bl> where UInt<Ul, Bl>: Cmp<Ur>, UInt<Ul, Bl>: PrivateDivFirstStep<Compare<UInt<Ul, Bl>, Ur>, Ur>`[src]

#### `type Output = PrivateDivFirstStepQuot<UInt<Ul, Bl>, Compare<UInt<Ul, Bl>, Ur>, Ur>`

The resulting type after applying the `/` operator

#### `fn div(self, _: Ur) -> Self::Output`

The method for the `/` operator

### `impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Rem<Ur> for UInt<Ul, Bl> where UInt<Ul, Bl>: Cmp<Ur>, UInt<Ul, Bl>: PrivateDivFirstStep<Compare<UInt<Ul, Bl>, Ur>, Ur>`[src]

#### `type Output = PrivateDivFirstStepRem<UInt<Ul, Bl>, Compare<UInt<Ul, Bl>, Ur>, Ur>`

The resulting type after applying the `%` operator

#### `fn rem(self, _: Ur) -> Self::Output`

The method for the `%` operator