Trait tuple::TupleElements

pub unsafe trait TupleElements: Sized {
    type Element;

    const N: usize;

    // Required methods
    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>;

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

Expand description

This trait 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> ⓘ

Object Safety§

This trait is not object safe.

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, 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>,

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>,

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