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

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<V: Eq, A: Eq> Eq for TArr<V, A>`

[src]

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

[src]

`fn eq(&self, __arg_0: &TArr<V, A>) -> bool`

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

`fn ne(&self, __arg_0: &TArr<V, A>) -> bool`

This method tests for `!=`

.

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

[src]

`fn cmp(&self, __arg_0: &TArr<V, A>) -> Ordering`

This method returns an `Ordering`

between `self`

and `other`

. Read more

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

[src]

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

This method returns an ordering between `self`

and `other`

values if one exists. Read more

`fn lt(&self, __arg_0: &TArr<V, A>) -> bool`

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

`fn le(&self, __arg_0: &TArr<V, A>) -> 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: &TArr<V, A>) -> bool`

This method tests greater than (for `self`

and `other`

) and is used by the `>`

operator. Read more

`fn ge(&self, __arg_0: &TArr<V, A>) -> bool`

This method tests greater than or equal to (for `self`

and `other`

) and is used by the `>=`

operator. Read more

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

[src]

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

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<V: Copy, A: Copy> Copy for TArr<V, A>`

[src]

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

[src]

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

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<V: Debug, A: Debug> Debug for TArr<V, A>`

[src]

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

[src]

`impl<V, A> Len for TArr<V, A> where A: Len,`

Length<A>: Add<B1>,

Sum<Length<A>, B1>: Unsigned

[src]

Length<A>: Add<B1>,

Sum<Length<A>, B1>: Unsigned

Size of a `TypeArray`

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

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<Al, Vl, Ar, Vr> Add<TArr<Vr, Ar>> for TArr<Vl, Al> where Al: Add<Ar>,`

Vl: Add<Vr>

[src]

Vl: Add<Vr>

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

The resulting type after applying the `+`

operator

`fn add(self, _: TArr<Vr, Ar>) -> Self::Output`

The method for the `+`

operator

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

Al: Sub<Ar>

[src]

Al: Sub<Ar>

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

The resulting type after applying the `-`

operator

`fn sub(self, _: TArr<Vr, Ar>) -> Self::Output`

The method for the `-`

operator

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

[src]

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

The resulting type after applying the `*`

operator

`fn mul(self, _: Rhs) -> Self::Output`

The method for the `*`

operator

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

[src]

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

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

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

A: PartialDiv<Rhs>

[src]

A: PartialDiv<Rhs>

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

The type of the result of the division

`fn partial_div(self, _: Rhs) -> Self::Output`

Method for performing the division

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

[src]

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

The resulting type after applying the `%`

operator

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

The method for the `%`

operator