Trait shrimple_parser::tuple::Tuple

pub trait Tuple: Sized {
    type Appended<NewElement>;
    type Prepended<NewElement>;
    type Reversed;

    // Required methods
    fn append<NewElement>(
        self,
        new_element: NewElement
    ) -> Self::Appended<NewElement>;
    fn prepend<NewElement>(
        self,
        new_element: NewElement
    ) -> Self::Prepended<NewElement>;
    fn rev(self) -> Self::Reversed;

    // Provided methods
    fn cloned(self) -> Self::Cloned
       where Self: CloneableRefs { ... }
    fn copied(self) -> Self::Copied
       where Self: CopiableRefs { ... }
    fn nth<const N: usize>(self) -> Self::Nth
       where Self: Index<N> { ... }
    fn nth_ref<const N: usize>(&self) -> &Self::Nth
       where Self: Index<N> { ... }
    fn map_nth<const N: usize, U>(
        self,
        f: impl FnOnce(Self::Nth) -> U
    ) -> Self::NthMapped<U>
       where Self: Index<N> { ... }
    fn first(self) -> Self::Nth
       where Self: Index<0> { ... }
    fn first_ref(&self) -> &Self::Nth
       where Self: Index<0> { ... }
    fn map_first<U>(self, f: impl FnOnce(Self::Nth) -> U) -> Self::NthMapped<U>
       where Self: Index<0> { ... }
    fn second(self) -> Self::Nth
       where Self: Index<1> { ... }
    fn second_ref(&self) -> &Self::Nth
       where Self: Index<1> { ... }
    fn map_second<U>(self, f: impl FnOnce(Self::Nth) -> U) -> Self::NthMapped<U>
       where Self: Index<1> { ... }
    fn third(self) -> Self::Nth
       where Self: Index<2> { ... }
    fn third_ref(&self) -> &Self::Nth
       where Self: Index<2> { ... }
    fn map_third<U>(self, f: impl FnOnce(Self::Nth) -> U) -> Self::NthMapped<U>
       where Self: Index<2> { ... }
    fn first_n<const N: usize>(self) -> Self::FirstN
       where Self: Slice<N> { ... }
    fn strip_first_n<const N: usize>(self) -> Self::FirstNStripped
       where Self: Slice<N> { ... }
    fn split<const N: usize>(self) -> (Self::FirstN, Self::FirstNStripped)
       where Self: Slice<N> { ... }
}

Trait for a generic tuple.

Required Associated Types

type Appended<NewElement>

The tuple + a new element at the end, the result of Tuple::append

type Prepended<NewElement>

The tuple + a new element at the start, the result of Tuple::prepend

type Reversed

The tuple with its elements in reverse order, the result of Tuple::rev

Required Methods

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

Adds new_element to the end of the tuple. Also see append

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

Adds new_element to the start of the tuple. Also see prepend

fn rev(self) -> Self::Reversed

Returns the tuple with its elements in reverse order. Also see rev

Provided Methods

fn cloned(self) -> Self::Cloned

where Self: CloneableRefs,

Clones the tuple element-wise, e.g. turn (&T, &U) into (T, U) Also see cloned

fn copied(self) -> Self::Copied

where Self: CopiableRefs,

Copies the tuple element-wise, e.g. turn (&T, &U) into (T, U) Also see copied

fn nth<const N: usize>(self) -> Self::Nth

where Self: Index<N>,

Returns the N-th element of the tuple. For shortcuts see Tuple::first, Tuple::second, Tuple::third

fn nth_ref<const N: usize>(&self) -> &Self::Nth

where Self: Index<N>,

Returns a reference to the N-th element of the tuple. For shortcuts see Tuple::first_ref, Tuple::second_ref, Tuple::third_ref

fn map_nth<const N: usize, U>( self, f: impl FnOnce(Self::Nth) -> U ) -> Self::NthMapped<U>

where Self: Index<N>,

Returns a function that transforms the N-th element of a tuple with f. For common shortcuts, see Tuple::map_first, Tuple::map_second, Tuple::map_third

fn first(self) -> Self::Nth

where Self: Index<0>,

Returns the first element of the tuple. For a more generic function, see Tuple::nth

fn first_ref(&self) -> &Self::Nth

where Self: Index<0>,

Returns a reference to the first element of the tuple. For a more generic function, see Tuple::nth_ref

fn map_first<U>(self, f: impl FnOnce(Self::Nth) -> U) -> Self::NthMapped<U>

where Self: Index<0>,

Transforms the first element of the tuple with f. For a more generic function, see Tuple::map_nth

fn second(self) -> Self::Nth

where Self: Index<1>,

Returns the second element of the tuple. For a more generic function, see Tuple::nth

fn second_ref(&self) -> &Self::Nth

where Self: Index<1>,

Returns a reference to the second element of the tuple. For a more generic function, see Tuple::nth_ref

fn map_second<U>(self, f: impl FnOnce(Self::Nth) -> U) -> Self::NthMapped<U>

where Self: Index<1>,

Transforms the second element of the tuple with f. For a more generic function, see Tuple::map_nth

fn third(self) -> Self::Nth

where Self: Index<2>,

Returns the third element of the tuple. For a more generic function, see Tuple::nth

fn third_ref(&self) -> &Self::Nth

where Self: Index<2>,

Returns a reference to the third element of the tuple. For a more generic function, see Tuple::nth_ref

fn map_third<U>(self, f: impl FnOnce(Self::Nth) -> U) -> Self::NthMapped<U>

where Self: Index<2>,

Transforms the third element of the tuple with f. For a more generic function, see Tuple::map_nth

fn first_n<const N: usize>(self) -> Self::FirstN

where Self: Slice<N>,

Returns a tuple that containing the first N elements of the original tuple. The other elements are discarded.

fn strip_first_n<const N: usize>(self) -> Self::FirstNStripped

where Self: Slice<N>,

Returns the original tuple with its first N elements discarded. Logical complement of Tuple::first_n

fn split<const N: usize>(self) -> (Self::FirstN, Self::FirstNStripped)

where Self: Slice<N>,

Splits the tuple into one with the first N elements and one with the rest.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Tuple for ()

type Appended<NewElement> = (NewElement,)

type Prepended<NewElement> = (NewElement,)

type Reversed = ()

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0> Tuple for (T0,)

type Appended<NewElement> = (T0, NewElement)

type Prepended<NewElement> = (NewElement, T0)

type Reversed = (T0,)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0, T1> Tuple for (T0, T1)

type Appended<NewElement> = (T0, T1, NewElement)

type Prepended<NewElement> = (NewElement, T0, T1)

type Reversed = (T1, T0)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0, T1, T2> Tuple for (T0, T1, T2)

type Appended<NewElement> = (T0, T1, T2, NewElement)

type Prepended<NewElement> = (NewElement, T0, T1, T2)

type Reversed = (T2, T1, T0)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0, T1, T2, T3> Tuple for (T0, T1, T2, T3)

type Appended<NewElement> = (T0, T1, T2, T3, NewElement)

type Prepended<NewElement> = (NewElement, T0, T1, T2, T3)

type Reversed = (T3, T2, T1, T0)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0, T1, T2, T3, T4> Tuple for (T0, T1, T2, T3, T4)

type Appended<NewElement> = (T0, T1, T2, T3, T4, NewElement)

type Prepended<NewElement> = (NewElement, T0, T1, T2, T3, T4)

type Reversed = (T4, T3, T2, T1, T0)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0, T1, T2, T3, T4, T5> Tuple for (T0, T1, T2, T3, T4, T5)

type Appended<NewElement> = (T0, T1, T2, T3, T4, T5, NewElement)

type Prepended<NewElement> = (NewElement, T0, T1, T2, T3, T4, T5)

type Reversed = (T5, T4, T3, T2, T1, T0)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0, T1, T2, T3, T4, T5, T6> Tuple for (T0, T1, T2, T3, T4, T5, T6)

type Appended<NewElement> = (T0, T1, T2, T3, T4, T5, T6, NewElement)

type Prepended<NewElement> = (NewElement, T0, T1, T2, T3, T4, T5, T6)

type Reversed = (T6, T5, T4, T3, T2, T1, T0)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

impl<T0, T1, T2, T3, T4, T5, T6, T7> Tuple for (T0, T1, T2, T3, T4, T5, T6, T7)

type Appended<NewElement> = (T0, T1, T2, T3, T4, T5, T6, T7, NewElement)

type Prepended<NewElement> = (NewElement, T0, T1, T2, T3, T4, T5, T6, T7)

type Reversed = (T7, T6, T5, T4, T3, T2, T1, T0)

fn append<NewElement>( self, new_element: NewElement ) -> Self::Appended<NewElement>

fn prepend<NewElement>( self, new_element: NewElement ) -> Self::Prepended<NewElement>

fn rev(self) -> Self::Reversed

Implementors