Struct TArr
pub struct TArr<V, A> { /* private fields */ }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>,
type Output = TArr<<Vl as Add<Vr>>::Output, <Al as Add<Ar>>::Output>;fn add(self, rhs: TArr<Vr, Ar>) -> Self::Output
impl<V, A> FoldAdd for TArr<V, A>
where
A: FoldAdd,
FoldSum<A>: Add<V>,
type Output = <<A as FoldAdd>::Output as Add<V>>::Output;
impl<V, A> FoldMul for TArr<V, A>
where
A: FoldMul,
FoldProd<A>: Mul<V>,
type Output = <<A as FoldMul>::Output as Mul<V>>::Output;
impl<V, A> Len for TArr<V, A>
where
A: Len,
Length<A>: Add<B1>,
Sum<Length<A>, B1>: Unsigned,
type Output = <<A as Len>::Output as Add<B1>>::Output;fn len(&self) -> Self::Output
impl<V, A> Neg for TArr<V, A>
where
V: Neg,
A: Neg,
type Output = TArr<<V as Neg>::Output, <A as Neg>::Output>;fn neg(self) -> Self::Output
impl<V, A> TypeArray for TArr<V, A>
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>;fn div(self, rhs: Rhs) -> Self::Output
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>;fn mul(self, rhs: Rhs) -> Self::Output
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>;fn partial_div(self, rhs: Rhs) -> Self::Output
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>;fn rem(self, rhs: Rhs) -> Self::Output
impl<V: Clone, A: Clone> Clone for TArr<V, A>
fn clone(&self) -> Self
impl<V: Copy, A: Copy> Copy for TArr<V, A>
impl<V: Debug, A: Debug> Debug for TArr<V, A>
fn fmt(&self, f: &mut Formatter<'_>) -> Result
impl<V: Eq, A: Eq> Eq for TArr<V, A>
impl<V: Hash, A: Hash> Hash for TArr<V, A>
fn hash<__H: Hasher>(&self, state: &mut __H)
impl<V: Ord, A: Ord> Ord for TArr<V, A>
fn cmp(&self, other: &Self) -> Ordering
impl<V: PartialEq, A: PartialEq> PartialEq for TArr<V, A>
fn eq(&self, other: &Self) -> bool
impl<V: PartialEq, A: PartialEq> StructuralPartialEq for TArr<V, A>
impl<V: PartialOrd, A: PartialOrd> PartialOrd for TArr<V, A>
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
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>;fn sub(self, rhs: TArr<Vr, Ar>) -> Self::Output
Auto Trait Implementations
impl<V, A> Freeze for TArr<V, A>
where
V: Freeze,
A: Freeze,
impl<V, A> RefUnwindSafe for TArr<V, A>
where
V: RefUnwindSafe,
A: RefUnwindSafe,
impl<V, A> Send for TArr<V, A>
where
V: Send,
A: Send,
impl<V, A> Sync for TArr<V, A>
where
V: Sync,
A: Sync,
impl<V, A> Unpin for TArr<V, A>
where
V: Unpin,
A: Unpin,
impl<V, A> UnsafeUnpin for TArr<V, A>
where
V: UnsafeUnpin,
A: UnsafeUnpin,
impl<V, A> UnwindSafe for TArr<V, A>
where
V: UnwindSafe,
A: UnwindSafe,
Blanket Implementations
impl<T> Any for TArr<V, A>
where
T: 'static + ?Sized,
fn type_id(&self) -> TypeId
impl<T> Borrow<T> for TArr<V, A>
where
T: ?Sized,
fn borrow(&self) -> &T
impl<T> BorrowMut<T> for TArr<V, A>
where
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
impl<T> CloneToUninit for TArr<V, A>
where
T: Clone,
unsafe fn clone_to_uninit(&self, dest: *mut u8)
impl<T> From<T> for TArr<V, A>
fn from(t: T) -> TReturns the argument unchanged.
impl<T> Same for TArr<V, A>
type Output = T;
impl<T, U> Into<U> for TArr<V, A>
where
U: From<T>,
fn into(self) -> UCalls
U::from(self).That is, this conversion is whatever the implementation of
[From]<T> for Uchooses to do.
impl<T, U> TryFrom<U> for TArr<V, A>
where
U: Into<T>,
type Error = never;fn try_from(value: U) -> Result<T, never>
impl<T, U> TryInto<U> for TArr<V, A>
where
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error;fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>