Trait TupleRemoveExact

pub trait TupleRemoveExact<const POS: usize> {
    type Output;

    // Required method
    fn remove(self) -> Self::Output;
}

Remove a value from a tuple.

This is internally used behind the TupleRemove 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::TupleRemoveExact;

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

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

Required Associated Types

type Output

Required Methods

fn remove(self) -> Self::Output

Implementations on Foreign Types

impl<A> TupleRemoveExact<0> for (A,)

type Output = ()

fn remove(self) -> Self::Output

impl<A, B> TupleRemoveExact<0> for (A, B)

type Output = (B,)

fn remove(self) -> Self::Output

impl<A, B> TupleRemoveExact<1> for (A, B)

type Output = (A,)

fn remove(self) -> Self::Output

impl<A, B, C> TupleRemoveExact<0> for (A, B, C)

type Output = (B, C)

fn remove(self) -> Self::Output

impl<A, B, C> TupleRemoveExact<1> for (A, B, C)

type Output = (A, C)

fn remove(self) -> Self::Output

impl<A, B, C> TupleRemoveExact<2> for (A, B, C)

type Output = (A, B)

fn remove(self) -> Self::Output

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

type Output = (B, C, D)

fn remove(self) -> Self::Output

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

type Output = (A, C, D)

fn remove(self) -> Self::Output

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

type Output = (A, B, D)

fn remove(self) -> Self::Output

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

type Output = (A, B, C)

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

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

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

fn remove(self) -> Self::Output

Implementors