Trait TupleInsertExact

Source
pub trait TupleInsertExact<const POS: usize, T> {
    type Output;

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

Insert a value into a tuple.

This is internally used behind the TupleInsert trait for convenience.

However, if something goes wrong with the trait solver, this trait can also be used explicitly.

§Example

use rs_std_ext::tuple::TupleInsertExact;

let x = (10u8, 'a');
let y = <(u8, char) as TupleInsertExact<1, _>>::insert(x, -5i32);

assert_eq!(y, (10u8, -5i32, 'a'));

Required Associated Types§

Required Methods§

Source

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

Implementations on Foreign Types§

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<0, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<1, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<2, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<3, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<4, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<5, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<6, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<7, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<8, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<9, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, J, Z> TupleInsertExact<10, Z> for (A, B, C, D, E, F, G, H, I, J)

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<0, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (Z, A, B, C, D, E, F, G, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<1, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, Z, B, C, D, E, F, G, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<2, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, Z, C, D, E, F, G, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<3, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, C, Z, D, E, F, G, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<4, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, C, D, Z, E, F, G, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<5, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, C, D, E, Z, F, G, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<6, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, C, D, E, F, Z, G, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<7, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, C, D, E, F, G, Z, H, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<8, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, C, D, E, F, G, H, Z, I)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, I, Z> TupleInsertExact<9, Z> for (A, B, C, D, E, F, G, H, I)

§

type Output = (A, B, C, D, E, F, G, H, I, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<0, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (Z, A, B, C, D, E, F, G, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<1, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, Z, B, C, D, E, F, G, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<2, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, B, Z, C, D, E, F, G, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<3, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, B, C, Z, D, E, F, G, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<4, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, B, C, D, Z, E, F, G, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<5, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, B, C, D, E, Z, F, G, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<6, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, B, C, D, E, F, Z, G, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<7, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, B, C, D, E, F, G, Z, H)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, H, Z> TupleInsertExact<8, Z> for (A, B, C, D, E, F, G, H)

§

type Output = (A, B, C, D, E, F, G, H, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<0, Z> for (A, B, C, D, E, F, G)

§

type Output = (Z, A, B, C, D, E, F, G)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<1, Z> for (A, B, C, D, E, F, G)

§

type Output = (A, Z, B, C, D, E, F, G)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<2, Z> for (A, B, C, D, E, F, G)

§

type Output = (A, B, Z, C, D, E, F, G)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<3, Z> for (A, B, C, D, E, F, G)

§

type Output = (A, B, C, Z, D, E, F, G)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<4, Z> for (A, B, C, D, E, F, G)

§

type Output = (A, B, C, D, Z, E, F, G)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<5, Z> for (A, B, C, D, E, F, G)

§

type Output = (A, B, C, D, E, Z, F, G)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<6, Z> for (A, B, C, D, E, F, G)

§

type Output = (A, B, C, D, E, F, Z, G)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, G, Z> TupleInsertExact<7, Z> for (A, B, C, D, E, F, G)

§

type Output = (A, B, C, D, E, F, G, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, Z> TupleInsertExact<0, Z> for (A, B, C, D, E, F)

§

type Output = (Z, A, B, C, D, E, F)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, Z> TupleInsertExact<1, Z> for (A, B, C, D, E, F)

§

type Output = (A, Z, B, C, D, E, F)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, Z> TupleInsertExact<2, Z> for (A, B, C, D, E, F)

§

type Output = (A, B, Z, C, D, E, F)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, Z> TupleInsertExact<3, Z> for (A, B, C, D, E, F)

§

type Output = (A, B, C, Z, D, E, F)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, Z> TupleInsertExact<4, Z> for (A, B, C, D, E, F)

§

type Output = (A, B, C, D, Z, E, F)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, Z> TupleInsertExact<5, Z> for (A, B, C, D, E, F)

§

type Output = (A, B, C, D, E, Z, F)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, F, Z> TupleInsertExact<6, Z> for (A, B, C, D, E, F)

§

type Output = (A, B, C, D, E, F, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, Z> TupleInsertExact<0, Z> for (A, B, C, D, E)

§

type Output = (Z, A, B, C, D, E)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, Z> TupleInsertExact<1, Z> for (A, B, C, D, E)

§

type Output = (A, Z, B, C, D, E)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, Z> TupleInsertExact<2, Z> for (A, B, C, D, E)

§

type Output = (A, B, Z, C, D, E)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, Z> TupleInsertExact<3, Z> for (A, B, C, D, E)

§

type Output = (A, B, C, Z, D, E)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, Z> TupleInsertExact<4, Z> for (A, B, C, D, E)

§

type Output = (A, B, C, D, Z, E)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, E, Z> TupleInsertExact<5, Z> for (A, B, C, D, E)

§

type Output = (A, B, C, D, E, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, Z> TupleInsertExact<0, Z> for (A, B, C, D)

§

type Output = (Z, A, B, C, D)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, Z> TupleInsertExact<1, Z> for (A, B, C, D)

§

type Output = (A, Z, B, C, D)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, Z> TupleInsertExact<2, Z> for (A, B, C, D)

§

type Output = (A, B, Z, C, D)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, Z> TupleInsertExact<3, Z> for (A, B, C, D)

§

type Output = (A, B, C, Z, D)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, D, Z> TupleInsertExact<4, Z> for (A, B, C, D)

§

type Output = (A, B, C, D, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, Z> TupleInsertExact<0, Z> for (A, B, C)

§

type Output = (Z, A, B, C)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, Z> TupleInsertExact<1, Z> for (A, B, C)

§

type Output = (A, Z, B, C)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, Z> TupleInsertExact<2, Z> for (A, B, C)

§

type Output = (A, B, Z, C)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, C, Z> TupleInsertExact<3, Z> for (A, B, C)

§

type Output = (A, B, C, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, Z> TupleInsertExact<0, Z> for (A, B)

§

type Output = (Z, A, B)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, Z> TupleInsertExact<1, Z> for (A, B)

§

type Output = (A, Z, B)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, B, Z> TupleInsertExact<2, Z> for (A, B)

§

type Output = (A, B, Z)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, Z> TupleInsertExact<0, Z> for (A,)

§

type Output = (Z, A)

§

fn insert(self, val: Z) -> Self::Output

§

impl<A, Z> TupleInsertExact<1, Z> for (A,)

§

type Output = (A, Z)

§

fn insert(self, val: Z) -> Self::Output

Implementors§