Trait tuple::TupleElements

pub unsafe trait TupleElements: Sized {
    type Element;

    const N: usize;

    fn get(&self, n: usize) -> Option<&Self::Element>;
    fn get_mut(&mut self, n: usize) -> Option<&mut Self::Element>;
    fn from_iter<I>(iter: I) -> Option<Self>
    where
        I: Iterator<Item = Self::Element>;

    fn elements(&self) -> Elements<&Self>  { ... }
    fn elements_mut(&mut self) -> Elements<&mut Self>  { ... }
    fn into_elements(self) -> IntoElements<Self>  { ... }
}

This trais is marked as unsafe, due to the requirement of the get_mut method, which is required work as an injective map of index -> element

A tuple must not have a Drop implementation.

Required Associated Types

type Element

Required Associated Constants

const N: usize

Required Methods

fn get(&self, n: usize) -> Option<&Self::Element>

attempt to access the n-th element

fn get_mut(&mut self, n: usize) -> Option<&mut Self::Element>

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>where
    I: Iterator<Item = Self::Element>,

Provided Methods

fn elements(&self) -> Elements<&Self>

returns an Iterator over references to the elements of the tuple

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>

Implementations on Foreign Types

impl<T> TupleElements for [T; 1]

type Element = T

const N: usize = 1usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 2]

type Element = T

const N: usize = 2usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 3]

type Element = T

const N: usize = 3usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 4]

type Element = T

const N: usize = 4usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 5]

type Element = T

const N: usize = 5usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 6]

type Element = T

const N: usize = 6usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 7]

type Element = T

const N: usize = 7usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 8]

type Element = T

const N: usize = 8usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 9]

type Element = T

const N: usize = 9usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 10]

type Element = T

const N: usize = 10usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 11]

type Element = T

const N: usize = 11usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 12]

type Element = T

const N: usize = 12usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 13]

type Element = T

const N: usize = 13usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 14]

type Element = T

const N: usize = 14usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 15]

type Element = T

const N: usize = 15usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for [T; 16]

type Element = T

const N: usize = 16usize

fn elements(&self) -> Elements<&Self>

fn elements_mut(&mut self) -> Elements<&mut Self>

fn into_elements(self) -> IntoElements<Self>

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T,)

type Element = T

const N: usize = 1usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T)

type Element = T

const N: usize = 2usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T)

type Element = T

const N: usize = 3usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T)

type Element = T

const N: usize = 4usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T)

type Element = T

const N: usize = 5usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T)

type Element = T

const N: usize = 6usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T)

type Element = T

const N: usize = 7usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 8usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 9usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 10usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 11usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 12usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 13usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 14usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 15usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

impl<T> TupleElements for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)

type Element = T

const N: usize = 16usize

fn get(&self, index: usize) -> Option<&T>

fn get_mut(&mut self, index: usize) -> Option<&mut T>

fn from_iter<I>(iter: I) -> Option<Self>where
    I: Iterator<Item = Self::Element>,

Implementors

impl<T> TupleElements for T1<T>

type Element = T

const N: usize = 1usize

impl<T> TupleElements for T2<T, T>

type Element = T

const N: usize = 2usize

impl<T> TupleElements for T3<T, T, T>

type Element = T

const N: usize = 3usize

impl<T> TupleElements for T4<T, T, T, T>

type Element = T

const N: usize = 4usize

impl<T> TupleElements for T5<T, T, T, T, T>

type Element = T

const N: usize = 5usize

impl<T> TupleElements for T6<T, T, T, T, T, T>

type Element = T

const N: usize = 6usize

impl<T> TupleElements for T7<T, T, T, T, T, T, T>

type Element = T

const N: usize = 7usize

impl<T> TupleElements for T8<T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 8usize

impl<T> TupleElements for T9<T, T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 9usize

impl<T> TupleElements for T10<T, T, T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 10usize

impl<T> TupleElements for T11<T, T, T, T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 11usize

impl<T> TupleElements for T12<T, T, T, T, T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 12usize

impl<T> TupleElements for T13<T, T, T, T, T, T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 13usize

impl<T> TupleElements for T14<T, T, T, T, T, T, T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 14usize

impl<T> TupleElements for T15<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T>

type Element = T

const N: usize = 15usize

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