pub struct T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(pub A, pub B, pub C, pub D, pub E, pub F, pub G, pub H, pub I, pub J, pub K, pub L, pub M, pub N, pub O, pub P);
Tuple Fields§
§0: A
§1: B
§2: C
§3: D
§4: E
§5: F
§6: G
§7: H
§8: I
§9: J
§10: K
§11: L
§12: M
§13: N
§14: O
§15: P
Implementations§
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<'a, T> T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>where
T: Clone,
impl<'a, T> T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>where
T: Clone,
pub fn from_slice(slice: &'a [T]) -> Option<Self>
Trait Implementations§
source§impl<T> Add<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> Add<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
§type Output = T16<<T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output>
type Output = T16<<T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output, <T as Add>::Output>
The resulting type after applying the
+
operator.source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Add for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Add for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
§type Output = T16<<A as Add>::Output, <B as Add>::Output, <C as Add>::Output, <D as Add>::Output, <E as Add>::Output, <F as Add>::Output, <G as Add>::Output, <H as Add>::Output, <I as Add>::Output, <J as Add>::Output, <K as Add>::Output, <L as Add>::Output, <M as Add>::Output, <N as Add>::Output, <O as Add>::Output, <P as Add>::Output>
type Output = T16<<A as Add>::Output, <B as Add>::Output, <C as Add>::Output, <D as Add>::Output, <E as Add>::Output, <F as Add>::Output, <G as Add>::Output, <H as Add>::Output, <I as Add>::Output, <J as Add>::Output, <K as Add>::Output, <L as Add>::Output, <M as Add>::Output, <N as Add>::Output, <O as Add>::Output, <P as Add>::Output>
The resulting type after applying the
+
operator.source§impl<T> AddAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> AddAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
source§fn add_assign(&mut self, rhs: T)
fn add_assign(&mut self, rhs: T)
Performs the
+=
operation. Read moresource§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> AddAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> AddAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§fn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
Performs the
+=
operation. Read moresource§impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Call<T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>> for Funcwhere
Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,
impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Call<T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>> for Funcwhere
Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,
source§impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> CallMut<T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>> for Funcwhere
Func: FnMut(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,
impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> CallMut<T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>> for Funcwhere
Func: FnMut(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,
source§impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> CallOnce<T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>> for Funcwhere
Func: FnOnce(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,
impl<Func, Out, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> CallOnce<T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>> for Funcwhere
Func: FnOnce(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Out,
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Clone for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Clone for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Debug for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Debug for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Default for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Default for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Deserialize<'de> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>where
A: Deserialize<'de>,
B: Deserialize<'de>,
C: Deserialize<'de>,
D: Deserialize<'de>,
E: Deserialize<'de>,
F: Deserialize<'de>,
G: Deserialize<'de>,
H: Deserialize<'de>,
I: Deserialize<'de>,
J: Deserialize<'de>,
K: Deserialize<'de>,
L: Deserialize<'de>,
M: Deserialize<'de>,
N: Deserialize<'de>,
O: Deserialize<'de>,
P: Deserialize<'de>,
impl<'de, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Deserialize<'de> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>where
A: Deserialize<'de>,
B: Deserialize<'de>,
C: Deserialize<'de>,
D: Deserialize<'de>,
E: Deserialize<'de>,
F: Deserialize<'de>,
G: Deserialize<'de>,
H: Deserialize<'de>,
I: Deserialize<'de>,
J: Deserialize<'de>,
K: Deserialize<'de>,
L: Deserialize<'de>,
M: Deserialize<'de>,
N: Deserialize<'de>,
O: Deserialize<'de>,
P: Deserialize<'de>,
source§fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>where
De: Deserializer<'de>,
fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>where
De: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§impl<T> Div<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> Div<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
§type Output = T16<<T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output>
type Output = T16<<T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output, <T as Div>::Output>
The resulting type after applying the
/
operator.source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Div for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Div for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
§type Output = T16<<A as Div>::Output, <B as Div>::Output, <C as Div>::Output, <D as Div>::Output, <E as Div>::Output, <F as Div>::Output, <G as Div>::Output, <H as Div>::Output, <I as Div>::Output, <J as Div>::Output, <K as Div>::Output, <L as Div>::Output, <M as Div>::Output, <N as Div>::Output, <O as Div>::Output, <P as Div>::Output>
type Output = T16<<A as Div>::Output, <B as Div>::Output, <C as Div>::Output, <D as Div>::Output, <E as Div>::Output, <F as Div>::Output, <G as Div>::Output, <H as Div>::Output, <I as Div>::Output, <J as Div>::Output, <K as Div>::Output, <L as Div>::Output, <M as Div>::Output, <N as Div>::Output, <O as Div>::Output, <P as Div>::Output>
The resulting type after applying the
/
operator.source§impl<T> DivAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> DivAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
source§fn div_assign(&mut self, rhs: T)
fn div_assign(&mut self, rhs: T)
Performs the
/=
operation. Read moresource§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> DivAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> DivAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§fn div_assign(&mut self, rhs: Self)
fn div_assign(&mut self, rhs: Self)
Performs the
/=
operation. Read moresource§impl<T> From<[T; 16]> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> From<[T; 16]> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
This is only avaible with the ‘nightly’ feature
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§fn from(t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) -> Self
fn from(t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) -> Self
Converts to this type from the input type.
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<u16> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> From<u16> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Hash for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Hash for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Into<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Into<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§fn into(self) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
fn into(self) -> (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
Converts this type into the (usually inferred) input type.
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Iterator for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Iterator for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
§type Item = T16<<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item, <M as Iterator>::Item, <N as Iterator>::Item, <O as Iterator>::Item, <P as Iterator>::Item>
type Item = T16<<A as Iterator>::Item, <B as Iterator>::Item, <C as Iterator>::Item, <D as Iterator>::Item, <E as Iterator>::Item, <F as Iterator>::Item, <G as Iterator>::Item, <H as Iterator>::Item, <I as Iterator>::Item, <J as Iterator>::Item, <K as Iterator>::Item, <L as Iterator>::Item, <M as Iterator>::Item, <N as Iterator>::Item, <O as Iterator>::Item, <P as Iterator>::Item>
The type of the elements being iterated over.
source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
Advances the iterator and returns the next value. Read more
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
🔬This is a nightly-only experimental API. (
iter_next_chunk
)Advances the iterator and returns an array containing the next
N
values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
Returns the bounds on the remaining length of the iterator. Read more
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
Consumes the iterator, counting the number of iterations and returning it. Read more
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
Consumes the iterator, returning the last element. Read more
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
🔬This is a nightly-only experimental API. (
iter_advance_by
)Advances the iterator by
n
elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
Returns the
n
th element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
Creates an iterator starting at the same point, but stepping by
the given amount at each iteration. Read more
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
Takes two iterators and creates a new iterator over both in sequence. Read more
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
‘Zips up’ two iterators into a single iterator of pairs. Read more
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
🔬This is a nightly-only experimental API. (
iter_intersperse
)Creates a new iterator which places an item generated by
separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
Takes a closure and creates an iterator which calls that closure on each
element. Read more
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
Creates an iterator which uses a closure to determine if an element
should be yielded. Read more
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
Creates an iterator that both filters and maps. Read more
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
Creates an iterator which gives the current iteration count as well as
the next value. Read more
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
Creates an iterator that yields elements based on a predicate. Read more
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
Creates an iterator that both yields elements based on a predicate and maps. Read more
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
Creates an iterator that skips the first
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
Creates an iterator that yields the first
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
Creates an iterator that works like map, but flattens nested structure. Read more
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
🔬This is a nightly-only experimental API. (
iter_map_windows
)Calls the given function
f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
Does something with each element of an iterator, passing the value on. Read more
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
Borrows an iterator, rather than consuming it. Read more
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
🔬This is a nightly-only experimental API. (
iter_collect_into
)Collects all the items from an iterator into a collection. Read more
1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
Consumes an iterator, creating two collections from it. Read more
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
🔬This is a nightly-only experimental API. (
iter_is_partitioned
)Checks if the elements of this iterator are partitioned according to the given predicate,
such that all those that return
true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
An iterator method that applies a function as long as it returns
successfully, producing a single, final value. Read more
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
An iterator method that applies a fallible function to each item in the
iterator, stopping at the first error and returning that error. Read more
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
Folds every element into an accumulator by applying an operation,
returning the final result. Read more
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
Reduces the elements to a single one, by repeatedly applying a reducing
operation. Read more
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
🔬This is a nightly-only experimental API. (
iterator_try_reduce
)Reduces the elements to a single one by repeatedly applying a reducing operation. If the
closure returns a failure, the failure is propagated back to the caller immediately. Read more
1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
Tests if every element of the iterator matches a predicate. Read more
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
Tests if any element of the iterator matches a predicate. Read more
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
Searches for an element of an iterator that satisfies a predicate. Read more
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
Applies function to the elements of iterator and returns
the first non-none result. Read more
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
🔬This is a nightly-only experimental API. (
try_find
)Applies function to the elements of iterator and returns
the first true result or the first error. Read more
1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
Searches for an element in an iterator, returning its index. Read more
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
Returns the element that gives the maximum value from the
specified function. Read more
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
Returns the element that gives the maximum value with respect to the
specified comparison function. Read more
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
Returns the element that gives the minimum value from the
specified function. Read more
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
Returns the element that gives the minimum value with respect to the
specified comparison function. Read more
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
Converts an iterator of pairs into a pair of containers. Read more
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
Creates an iterator which copies all of its elements. Read more
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
🔬This is a nightly-only experimental API. (
iter_array_chunks
)Returns an iterator over
N
elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
Iterates over the entire iterator, multiplying all the elements Read more
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
🔬This is a nightly-only experimental API. (
iter_order_by
)Lexicographically compares the elements of this
Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
Lexicographically compares the
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
🔬This is a nightly-only experimental API. (
iter_order_by
)Lexicographically compares the elements of this
Iterator
with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
🔬This is a nightly-only experimental API. (
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Determines if the elements of this
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Determines if the elements of this
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Determines if the elements of this
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Determines if the elements of this
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
🔬This is a nightly-only experimental API. (
is_sorted
)Checks if the elements of this iterator are sorted using the given comparator function. Read more
source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
🔬This is a nightly-only experimental API. (
is_sorted
)Checks if the elements of this iterator are sorted using the given key extraction
function. Read more
source§impl<T> Mul<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> Mul<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
§type Output = T16<<T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output>
type Output = T16<<T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output, <T as Mul>::Output>
The resulting type after applying the
*
operator.source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Mul for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Mul for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
§type Output = T16<<A as Mul>::Output, <B as Mul>::Output, <C as Mul>::Output, <D as Mul>::Output, <E as Mul>::Output, <F as Mul>::Output, <G as Mul>::Output, <H as Mul>::Output, <I as Mul>::Output, <J as Mul>::Output, <K as Mul>::Output, <L as Mul>::Output, <M as Mul>::Output, <N as Mul>::Output, <O as Mul>::Output, <P as Mul>::Output>
type Output = T16<<A as Mul>::Output, <B as Mul>::Output, <C as Mul>::Output, <D as Mul>::Output, <E as Mul>::Output, <F as Mul>::Output, <G as Mul>::Output, <H as Mul>::Output, <I as Mul>::Output, <J as Mul>::Output, <K as Mul>::Output, <L as Mul>::Output, <M as Mul>::Output, <N as Mul>::Output, <O as Mul>::Output, <P as Mul>::Output>
The resulting type after applying the
*
operator.source§impl<T> MulAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> MulAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
source§fn mul_assign(&mut self, rhs: T)
fn mul_assign(&mut self, rhs: T)
Performs the
*=
operation. Read moresource§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> MulAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> MulAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§fn mul_assign(&mut self, rhs: Self)
fn mul_assign(&mut self, rhs: Self)
Performs the
*=
operation. Read moresource§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Neg for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Neg for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
§type Output = T16<<A as Neg>::Output, <B as Neg>::Output, <C as Neg>::Output, <D as Neg>::Output, <E as Neg>::Output, <F as Neg>::Output, <G as Neg>::Output, <H as Neg>::Output, <I as Neg>::Output, <J as Neg>::Output, <K as Neg>::Output, <L as Neg>::Output, <M as Neg>::Output, <N as Neg>::Output, <O as Neg>::Output, <P as Neg>::Output>
type Output = T16<<A as Neg>::Output, <B as Neg>::Output, <C as Neg>::Output, <D as Neg>::Output, <E as Neg>::Output, <F as Neg>::Output, <G as Neg>::Output, <H as Neg>::Output, <I as Neg>::Output, <J as Neg>::Output, <K as Neg>::Output, <L as Neg>::Output, <M as Neg>::Output, <N as Neg>::Output, <O as Neg>::Output, <P as Neg>::Output>
The resulting type after applying the
-
operator.source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> OpReverse for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> OpReverse for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> OpRotateLeft for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> OpRotateLeft for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> OpRotateRight for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> OpRotateRight for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PartialEq for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> PartialEq for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Serialize for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Serialize for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§impl<T> Sub<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> Sub<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
§type Output = T16<<T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output>
type Output = T16<<T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output, <T as Sub>::Output>
The resulting type after applying the
-
operator.source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Sub for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Sub for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
§type Output = T16<<A as Sub>::Output, <B as Sub>::Output, <C as Sub>::Output, <D as Sub>::Output, <E as Sub>::Output, <F as Sub>::Output, <G as Sub>::Output, <H as Sub>::Output, <I as Sub>::Output, <J as Sub>::Output, <K as Sub>::Output, <L as Sub>::Output, <M as Sub>::Output, <N as Sub>::Output, <O as Sub>::Output, <P as Sub>::Output>
type Output = T16<<A as Sub>::Output, <B as Sub>::Output, <C as Sub>::Output, <D as Sub>::Output, <E as Sub>::Output, <F as Sub>::Output, <G as Sub>::Output, <H as Sub>::Output, <I as Sub>::Output, <J as Sub>::Output, <K as Sub>::Output, <L as Sub>::Output, <M as Sub>::Output, <N as Sub>::Output, <O as Sub>::Output, <P as Sub>::Output>
The resulting type after applying the
-
operator.source§impl<T> SubAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> SubAssign<T> for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
source§fn sub_assign(&mut self, rhs: T)
fn sub_assign(&mut self, rhs: T)
Performs the
-=
operation. Read moresource§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> SubAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> SubAssign for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
source§fn sub_assign(&mut self, rhs: Self)
fn sub_assign(&mut self, rhs: Self)
Performs the
-=
operation. Read moresource§impl<T> TupleElements for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
impl<T> TupleElements for T16<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>
type Element = T
const N: usize = 16usize
source§fn get_mut(&mut self, index: usize) -> Option<&mut T>
fn get_mut(&mut self, index: usize) -> Option<&mut T>
attempt to access the n-th element mutablbly.
This function shall not return the same data for two different indices.
fn from_iter<I>(iter: I) -> Option<Self>
source§fn elements(&self) -> Elements<&Self> ⓘ
fn elements(&self) -> Elements<&Self> ⓘ
returns an Iterator over references to the elements of the tuple
source§fn elements_mut(&mut self) -> Elements<&mut Self> ⓘ
fn elements_mut(&mut self) -> Elements<&mut Self> ⓘ
returns an Iterator over mutable references to elements of the tuple
fn into_elements(self) -> IntoElements<Self> ⓘ
source§impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Zero for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Zero for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Copy for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Eq for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
Auto Trait Implementations§
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> RefUnwindSafe for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>where
A: RefUnwindSafe,
B: RefUnwindSafe,
C: RefUnwindSafe,
D: RefUnwindSafe,
E: RefUnwindSafe,
F: RefUnwindSafe,
G: RefUnwindSafe,
H: RefUnwindSafe,
I: RefUnwindSafe,
J: RefUnwindSafe,
K: RefUnwindSafe,
L: RefUnwindSafe,
M: RefUnwindSafe,
N: RefUnwindSafe,
O: RefUnwindSafe,
P: RefUnwindSafe,
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Send for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Sync for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Unpin for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> UnwindSafe for T16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>where
A: UnwindSafe,
B: UnwindSafe,
C: UnwindSafe,
D: UnwindSafe,
E: UnwindSafe,
F: UnwindSafe,
G: UnwindSafe,
H: UnwindSafe,
I: UnwindSafe,
J: UnwindSafe,
K: UnwindSafe,
L: UnwindSafe,
M: UnwindSafe,
N: UnwindSafe,
O: UnwindSafe,
P: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more