TArr in typenum::array - Rust
Description: `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.
Keywords: rust, rustlang, rust-lang, TArr

# Struct typenum::array::TArr

source ·

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

Expand description

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

source§

### impl<Al, Vl, Ar, Vr> Add<TArr<Vr, Ar>> for TArr<Vl, Al>where
Al: Add<Ar>,
Vl: Add<Vr>,

§

#### type Output = TArr<<Vl as Add<Vr>>::Output, <Al as Add<Ar>>::Output>

The resulting type after applying the `+` operator.
source§

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

Performs the `+` operation. Read more
source§

### impl<V: Clone, A: Clone> Clone for TArr<V, A>

source§

#### fn clone(&self) -> TArr<V, A>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl<V: Debug, A: Debug> Debug for TArr<V, A>

source§

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

Formats the value using the given formatter. Read more
source§

### impl<V, A, Rhs> Div<Rhs> for TArr<V, A>where
V: Div<Rhs>,
A: Div<Rhs>,
Rhs: Copy,

§

#### type Output = TArr<<V as Div<Rhs>>::Output, <A as Div<Rhs>>::Output>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: Rhs) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<V: Hash, A: Hash> Hash for TArr<V, A>

source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<V, A> Len for TArr<V, A>where
A: Len,
Length<A>: Add<B1>,
Sum<Length<A>, B1>: Unsigned,

Size of a `TypeArray`

§

#### type Output = <<A as Len>::Output as Add<B1>>::Output

The length as a type-level unsigned integer.
source§

#### fn len(&self) -> Self::Output

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

### impl<V, A, Rhs> Mul<Rhs> for TArr<V, A>where
V: Mul<Rhs>,
A: Mul<Rhs>,
Rhs: Copy,

§

#### type Output = TArr<<V as Mul<Rhs>>::Output, <A as Mul<Rhs>>::Output>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Rhs) -> Self::Output

Performs the `*` operation. Read more
source§

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

§

#### type Output = TArr<<NInt<U> as Mul<V>>::Output, <NInt<U> as Mul<A>>::Output>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = TArr<<PInt<U> as Mul<V>>::Output, <PInt<U> as Mul<A>>::Output>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<V, A> Mul<TArr<V, A>> for Z0 where
Z0: Mul<A>,

§

#### type Output = TArr<Z0, <Z0 as Mul<A>>::Output>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<V, A> Neg for TArr<V, A>where
V: Neg,
A: Neg,

§

#### type Output = TArr<<V as Neg>::Output, <A as Neg>::Output>

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

### impl<V: Ord, A: Ord> Ord for TArr<V, A>

source§

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

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere
Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more
source§

### impl<V, A, Rhs> PartialDiv<Rhs> for TArr<V, A>where
V: PartialDiv<Rhs>,
A: PartialDiv<Rhs>,
Rhs: Copy,

§

#### type Output = TArr<<V as PartialDiv<Rhs>>::Output, <A as PartialDiv<Rhs>>::Output>

The type of the result of the division
source§

#### fn partial_div(self, rhs: Rhs) -> Self::Output

Method for performing the division
source§

### impl<V: PartialEq, A: PartialEq> PartialEq<TArr<V, A>> for TArr<V, A>

source§

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

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

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more
source§

### impl<V: PartialOrd, A: PartialOrd> PartialOrd<TArr<V, A>> for TArr<V, A>

source§

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

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

#### fn lt(&self, other: &Rhs) -> bool

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

#### fn le(&self, other: &Rhs) -> bool

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

#### fn gt(&self, other: &Rhs) -> bool

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

#### fn ge(&self, other: &Rhs) -> bool

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

### impl<V, A, Rhs> Rem<Rhs> for TArr<V, A>where
V: Rem<Rhs>,
A: Rem<Rhs>,
Rhs: Copy,

§

#### type Output = TArr<<V as Rem<Rhs>>::Output, <A as Rem<Rhs>>::Output>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, rhs: Rhs) -> Self::Output

Performs the `%` operation. Read more
source§

### impl<Vl, Al, Vr, Ar> Sub<TArr<Vr, Ar>> for TArr<Vl, Al>where
Vl: Sub<Vr>,
Al: Sub<Ar>,

§

#### type Output = TArr<<Vl as Sub<Vr>>::Output, <Al as Sub<Ar>>::Output>

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

### impl<V: Copy, A: Copy> Copy for TArr<V, A>

source§

### impl<V: Eq, A: Eq> Eq for TArr<V, A>

source§

### impl<V, A> StructuralEq for TArr<V, A>

source§

### impl<V, A> StructuralPartialEq for TArr<V, A>

source§

### impl<V, A> TypeArray for TArr<V, A>

## Auto Trait Implementations§

§

### impl<V, A> RefUnwindSafe for TArr<V, A>where
A: RefUnwindSafe,
V: RefUnwindSafe,

§

### impl<V, A> Send for TArr<V, A>where
A: Send,
V: Send,

§

### impl<V, A> Sync for TArr<V, A>where
A: Sync,
V: Sync,

§

### impl<V, A> Unpin for TArr<V, A>where
A: Unpin,
V: Unpin,

§

### impl<V, A> UnwindSafe for TArr<V, A>where
A: UnwindSafe,
V: UnwindSafe,

## Blanket Implementations§

source§

### impl<T> Any for Twhere
T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

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

### impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

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

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

const: unstable · source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

#### fn into(self) -> U

Calls `U::from(self)`.

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

source§

### impl<T> Same<T> for T

§

#### type Output = T

Should always be `Self`
source§

### impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

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

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
const: unstable · source§

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

Performs the conversion.