# [−] [src] Struct typenum::array::TArr

    pub struct TArr<V, A> { /* fields omitted */ }

`TArr` is a type that acts as an array of types. It is defined similarly to `UInt`, only its values can be more than bits, and it is designed to act as an array. So you can only add two if they have the same number of elements, for example.

This array is only really designed to contain `Integer` types. If you use it with others, you may find it lacking functionality.

## Trait Implementations

### `impl<Al, Vl, Ar, Vr> Add<TArr<Vr, Ar>> for TArr<Vl, Al> where
Al: Add<Ar>,
Vl: Add<Vr>,` [src]

#### `type Output = TArr<Sum<Vl, Vr>, Sum<Al, Ar>>`

The resulting type after applying the `+` operator.

#### `fn add(self, rhs: TArr<Vr, Ar>) -> Self::Output` [src]

Performs the `+` operation. Read more

### `impl<V: Clone, A: Clone> Clone for TArr<V, A>` [src]

#### `fn clone(&self) -> TArr<V, A>` [src]

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`. Read more

### `impl<V: Copy, A: Copy> Copy for TArr<V, A>` [src]

### `impl<V: Debug, A: Debug> Debug for TArr<V, A>` [src]

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

Formats the value using the given formatter. Read more

### `impl<V, A, Rhs> Div<Rhs> for TArr<V, A> where
V: Div<Rhs>,
A: Div<Rhs>,
Rhs: Copy,` [src]

#### `type Output = TArr<Quot<V, Rhs>, Quot<A, Rhs>>`

The resulting type after applying the `/` operator.

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

Performs the `/` operation. Read more

### `impl<V: Eq, A: Eq> Eq for TArr<V, A>` [src]

### `impl<V: Hash, A: Hash> Hash for TArr<V, A>` [src]

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

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

#### `pub 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<V, A> Len for TArr<V, A> where
A: Len,
Length<A>: Add<B1>,
Sum<Length<A>, B1>: Unsigned,` [src]

Size of a `TypeArray`

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

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<V, A, Rhs> Mul<Rhs> for TArr<V, A> where
V: Mul<Rhs>,
A: Mul<Rhs>,
Rhs: Copy,` [src]

#### `type Output = TArr<Prod<V, Rhs>, Prod<A, Rhs>>`

The resulting type after applying the `*` operator.

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

Performs the `*` operation. Read more

### `impl<V, A> Mul<TArr<V, A>> for Z0 where
Z0: Mul<A>,` [src]

#### `type Output = TArr<Z0, Prod<Z0, A>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: TArr<V, A>) -> Self::Output` [src]

Performs the `*` operation. Read more

### `impl<V, A, U> Mul<TArr<V, A>> for PInt<U> where
U: Unsigned + NonZero,
PInt<U>: Mul<A> + Mul<V>,` [src]

#### `type Output = TArr<Prod<PInt<U>, V>, Prod<PInt<U>, A>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: TArr<V, A>) -> Self::Output` [src]

Performs the `*` operation. Read more

### `impl<V, A, U> Mul<TArr<V, A>> for NInt<U> where
U: Unsigned + NonZero,
NInt<U>: Mul<A> + Mul<V>,` [src]

#### `type Output = TArr<Prod<NInt<U>, V>, Prod<NInt<U>, A>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: TArr<V, A>) -> Self::Output` [src]

Performs the `*` operation. Read more

### `impl<V, A> Neg for TArr<V, A> where
V: Neg,
A: Neg,` [src]

#### `type Output = TArr<Negate<V>, Negate<A>>`

The resulting type after applying the `-` operator.

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

Performs the unary `-` operation. Read more

### `impl<V: Ord, A: Ord> Ord for TArr<V, A>` [src]

#### `fn cmp(&self, other: &TArr<V, A>) -> Ordering` [src]

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

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

Compares and returns the maximum of two values. Read more

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

Compares and returns the minimum of two values. Read more

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

Restrict a value to a certain interval. Read more

### `impl<V, A, Rhs> PartialDiv<Rhs> for TArr<V, A> where
V: PartialDiv<Rhs>,
A: PartialDiv<Rhs>,
Rhs: Copy,` [src]

#### `type Output = TArr<PartialQuot<V, Rhs>, PartialQuot<A, Rhs>>`

The type of the result of the division

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

Method for performing the division

### `impl<V: PartialEq, A: PartialEq> PartialEq<TArr<V, A>> for TArr<V, A>` [src]

#### `fn eq(&self, other: &TArr<V, A>) -> bool` [src]

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

#### `fn ne(&self, other: &TArr<V, A>) -> bool` [src]

This method tests for `!=`.

### `impl<V: PartialOrd, A: PartialOrd> PartialOrd<TArr<V, A>> for TArr<V, A>` [src]

#### `fn partial_cmp(&self, other: &TArr<V, A>) -> Option<Ordering>` [src]

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

#### `fn lt(&self, other: &TArr<V, A>) -> bool` [src]

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

#### `fn le(&self, other: &TArr<V, A>) -> 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: &TArr<V, A>) -> bool` [src]

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

#### `fn ge(&self, other: &TArr<V, A>) -> bool` [src]

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

### `impl<V, A, Rhs> Rem<Rhs> for TArr<V, A> where
V: Rem<Rhs>,
A: Rem<Rhs>,
Rhs: Copy,` [src]

#### `type Output = TArr<Mod<V, Rhs>, Mod<A, Rhs>>`

The resulting type after applying the `%` operator.

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

Performs the `%` operation. Read more

### `impl<V, A> StructuralEq for TArr<V, A>` [src]

### `impl<V, A> StructuralPartialEq for TArr<V, A>` [src]

### `impl<Vl, Al, Vr, Ar> Sub<TArr<Vr, Ar>> for TArr<Vl, Al> where
Vl: Sub<Vr>,
Al: Sub<Ar>,` [src]

#### `type Output = TArr<Diff<Vl, Vr>, Diff<Al, Ar>>`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: TArr<Vr, Ar>) -> Self::Output` [src]

Performs the `-` operation. Read more

### `impl<V, A> TypeArray for TArr<V, A>` [src]

## Auto Trait Implementations

### `impl<V, A> Send for TArr<V, A> where
A: Send,
V: Send,` [src]

### `impl<V, A> Sync for TArr<V, A> where
A: Sync,
V: Sync,` [src]

### `impl<V, A> Unpin for TArr<V, A> where
A: Unpin,
V: Unpin,` [src]

## Blanket Implementations

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

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

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

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

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

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

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

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

Performs the conversion.

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

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

Performs the conversion.

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

#### `type Output = T`

Should always be `Self`

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

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [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.

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

Performs the conversion.