Struct Tuples

struct Tuples<I, T> { ... }
where
    I: Iterator<Item = <T as >::Item>,
    T: HomogeneousTuple

An iterator that groups the items in tuples of a specific size.

See .tuples() for more information.

Implementations

impl<I, T> Tuples<I, T>

fn into_buffer(self: Self) -> TupleBuffer<T>

Return a buffer with the produced items that was not enough to be grouped in a tuple.

use itertools::Itertools;

let mut iter = (0..5).tuples();
assert_eq!(Some((0, 1, 2)), iter.next());
assert_eq!(None, iter.next());
itertools::assert_equal(vec![3, 4], iter.into_buffer());

impl<I> IntoIterator for Tuples<I, T>

fn into_iter(self: Self) -> I

impl<I, T> Clone for Tuples<I, T>

fn clone(self: &Self) -> Tuples<I, T>

impl<I, T> Debug for Tuples<I, T>

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

impl<I, T> ExactSizeIterator for Tuples<I, T>

impl<I, T> Freeze for Tuples<I, T>

impl<I, T> Iterator for Tuples<I, T>

fn next(self: &mut Self) -> Option<<Self as >::Item>
fn size_hint(self: &Self) -> (usize, Option<usize>)

impl<I, T> RefUnwindSafe for Tuples<I, T>

impl<I, T> Send for Tuples<I, T>

impl<I, T> Sync for Tuples<I, T>

impl<I, T> Unpin for Tuples<I, T>

impl<I, T> UnsafeUnpin for Tuples<I, T>

impl<I, T> UnwindSafe for Tuples<I, T>

impl<IT, A, FromA> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA)

impl<IT, A, FromA, B, FromB> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB)

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip for Tuples<I, T>

fn multiunzip(self: Self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

impl<T> Any for Tuples<I, T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Tuples<I, T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Tuples<I, T>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for Tuples<I, T>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for Tuples<I, T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Itertools for Tuples<I, T>

impl<T> ToOwned for Tuples<I, T>

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T, U> Into for Tuples<I, T>

fn into(self: Self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom for Tuples<I, T>

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

impl<T, U> TryInto for Tuples<I, T>

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