Trait iterextd::TupleItern

pub trait TupleItern<'a> {
    type A;
    type B;

    // Required methods
    fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'a, Self::A, N> ;
    fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'a, Self::B, N> ;
}

Available on crate feature itern only.

A trait that allows iteration over N elements of a tuple.

Required Associated Types

type A

The type of immutable references yielded by the tuple iterator.

type B

The type of mutable references yielded by the tuple iterator.

Required Methods

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'a, Self::A, N>

Creates an iterator from a tuple that returns elements by reference.

The difference from the tuple_iter method is that it can get N elements.

Panics

If N is greater than the number of elements in the tuple, panic.

Examples

Basic usage:

use iterextd::TupleItern;

let tup = (5, 4, 3, 2, 1);
let mut tup_iter = tup.tuple_itern::<3>().rev();
assert_eq!(tup_iter.next(), Some(&3));
assert_eq!(tup_iter.next(), Some(&4));
assert_eq!(tup_iter.next(), Some(&5));
assert_eq!(tup_iter.next(), None);

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'a, Self::B, N>

Creates an iterator from a tuple that returns elements by mutable reference.

The difference from the tuple_iter_mut method is that it can get N elements.

Panics

If N is greater than the number of elements in the tuple, panic.

Examples

Basic usage:

use iterextd::TupleItern;

let mut tup = (vec![20], vec![21], vec![22], vec![23]);
let _ = tup.tuple_itern_mut::<2>().for_each(|elem| { elem[0] +=10;});
assert_eq!(tup, (vec![30], vec![31], vec![22], vec![23]));

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, T> TupleItern<'a> for (T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T, T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T, T, T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T, T, T, T, T, T, T, T, T, T, T, T)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

impl<'a, T> TupleItern<'a> for (T,)

type A = T

type B = T

fn tuple_itern<const N: usize>(&'a self) -> TupleImut<'_, Self::A, N>

fn tuple_itern_mut<const N: usize>(&'a mut self) -> TupleMut<'_, Self::B, N>

Implementors