Trait TupleInsert 

pub trait TupleInsert<Idx, T> {
    type Output;

    // Required method
    fn insert(self, value: T) -> Self::Output;
}

A trait for inserting an element at a specific index into a tuple.

This trait allows inserting an element at compile-time known index Idx into a tuple, returning the tuple with the element inserted.

Examples

use tuplities_insert::TupleInsert;
use typenum::U1;

let tuple = (1, 3.14);
let inserted = TupleInsert::<U1, _>::insert(tuple, "hello");
assert_eq!(inserted, (1, "hello", 3.14));

Part of the tuplities crate.

Required Associated Types

type Output

The type of the tuple after inserting the element.

Required Methods

fn insert(self, value: T) -> Self::Output

Inserts the element at index Idx into the tuple.

Returns the tuple with the element inserted at the specified index.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T2, T3, T4, T5, T6, T7, T8, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T2, T3, T4, T, T5, T6, T7, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T2, T3, T4, T5, T, T6, T7, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T2, T3, T4, T5, T6, T, T7, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T2, T3, T4, T5, T6, T7, T, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UInt<UTerm, B1>, B0>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T2, T, T3, T4, T5, T6, T7, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UInt<UTerm, B1>, B1>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T2, T3, T, T4, T5, T6, T7, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UInt<UTerm, B1>, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T1, T, T2, T3, T4, T5, T6, T7, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7, T8> TupleInsert<UTerm, T> for (T1, T2, T3, T4, T5, T6, T7, T8)

type Output = (T, T1, T2, T3, T4, T5, T6, T7, T8)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T1, T2, T3, T4, T, T5, T6, T7)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T1, T2, T3, T4, T5, T, T6, T7)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T1, T2, T3, T4, T5, T6, T, T7)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T1, T2, T3, T4, T5, T6, T7, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UInt<UInt<UTerm, B1>, B0>, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T1, T2, T, T3, T4, T5, T6, T7)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UInt<UInt<UTerm, B1>, B1>, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T1, T2, T3, T, T4, T5, T6, T7)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UInt<UTerm, B1>, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T1, T, T2, T3, T4, T5, T6, T7)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6, T7> TupleInsert<UTerm, T> for (T1, T2, T3, T4, T5, T6, T7)

type Output = (T, T1, T2, T3, T4, T5, T6, T7)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, T> for (T1, T2, T3, T4, T5, T6)

type Output = (T1, T2, T3, T4, T, T5, T6)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, T> for (T1, T2, T3, T4, T5, T6)

type Output = (T1, T2, T3, T4, T5, T, T6)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, T> for (T1, T2, T3, T4, T5, T6)

type Output = (T1, T2, T3, T4, T5, T6, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6> TupleInsert<UInt<UInt<UTerm, B1>, B0>, T> for (T1, T2, T3, T4, T5, T6)

type Output = (T1, T2, T, T3, T4, T5, T6)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6> TupleInsert<UInt<UInt<UTerm, B1>, B1>, T> for (T1, T2, T3, T4, T5, T6)

type Output = (T1, T2, T3, T, T4, T5, T6)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6> TupleInsert<UInt<UTerm, B1>, T> for (T1, T2, T3, T4, T5, T6)

type Output = (T1, T, T2, T3, T4, T5, T6)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5, T6> TupleInsert<UTerm, T> for (T1, T2, T3, T4, T5, T6)

type Output = (T, T1, T2, T3, T4, T5, T6)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, T> for (T1, T2, T3, T4, T5)

type Output = (T1, T2, T3, T4, T, T5)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, T> for (T1, T2, T3, T4, T5)

type Output = (T1, T2, T3, T4, T5, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5> TupleInsert<UInt<UInt<UTerm, B1>, B0>, T> for (T1, T2, T3, T4, T5)

type Output = (T1, T2, T, T3, T4, T5)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5> TupleInsert<UInt<UInt<UTerm, B1>, B1>, T> for (T1, T2, T3, T4, T5)

type Output = (T1, T2, T3, T, T4, T5)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5> TupleInsert<UInt<UTerm, B1>, T> for (T1, T2, T3, T4, T5)

type Output = (T1, T, T2, T3, T4, T5)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4, T5> TupleInsert<UTerm, T> for (T1, T2, T3, T4, T5)

type Output = (T, T1, T2, T3, T4, T5)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4> TupleInsert<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, T> for (T1, T2, T3, T4)

type Output = (T1, T2, T3, T4, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4> TupleInsert<UInt<UInt<UTerm, B1>, B0>, T> for (T1, T2, T3, T4)

type Output = (T1, T2, T, T3, T4)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4> TupleInsert<UInt<UInt<UTerm, B1>, B1>, T> for (T1, T2, T3, T4)

type Output = (T1, T2, T3, T, T4)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4> TupleInsert<UInt<UTerm, B1>, T> for (T1, T2, T3, T4)

type Output = (T1, T, T2, T3, T4)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3, T4> TupleInsert<UTerm, T> for (T1, T2, T3, T4)

type Output = (T, T1, T2, T3, T4)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3> TupleInsert<UInt<UInt<UTerm, B1>, B0>, T> for (T1, T2, T3)

type Output = (T1, T2, T, T3)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3> TupleInsert<UInt<UInt<UTerm, B1>, B1>, T> for (T1, T2, T3)

type Output = (T1, T2, T3, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3> TupleInsert<UInt<UTerm, B1>, T> for (T1, T2, T3)

type Output = (T1, T, T2, T3)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2, T3> TupleInsert<UTerm, T> for (T1, T2, T3)

type Output = (T, T1, T2, T3)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2> TupleInsert<UInt<UInt<UTerm, B1>, B0>, T> for (T1, T2)

type Output = (T1, T2, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2> TupleInsert<UInt<UTerm, B1>, T> for (T1, T2)

type Output = (T1, T, T2)

fn insert(self, value: T) -> Self::Output

impl<T, T1, T2> TupleInsert<UTerm, T> for (T1, T2)

type Output = (T, T1, T2)

fn insert(self, value: T) -> Self::Output

impl<T, T1> TupleInsert<UInt<UTerm, B1>, T> for (T1,)

type Output = (T1, T)

fn insert(self, value: T) -> Self::Output

impl<T, T1> TupleInsert<UTerm, T> for (T1,)

type Output = (T, T1)

fn insert(self, value: T) -> Self::Output

impl<T> TupleInsert<UTerm, T> for ()

type Output = (T,)

fn insert(self, value: T) -> Self::Output

Implementors