Trait KnownTuple 

pub trait KnownTuple<'a> {
    type RefTuple: 'a + KnownTuple<'a>;
    type FnPointer: KnownFnPointer<ArgsTuple = Self>;

    // Required method
    fn as_tuple_of_refs(&'a self) -> Self::RefTuple;
}

Required Associated Types

type RefTuple: 'a + KnownTuple<'a>

The corresponding tuple type which references each item.

use tuple_fn::KnownTuple;

let _: <() as KnownTuple>::RefTuple = ();
let _: <(i32,) as KnownTuple>::RefTuple = (&1,);
let _: <(i32, bool) as KnownTuple>::RefTuple = (&1, &true);
let _: <(i32, bool, &u8) as KnownTuple>::RefTuple = (&1, &true, &&0u8);

type FnPointer: KnownFnPointer<ArgsTuple = Self>

The fn pointer type which accepts this tuple as arguments and returns (). For example, the following types in each pair are equivalent.

<() as KnownTuple>::FnPointer, fn()
<(i32,) as KnownTuple>::FnPointer, fn(i32)
<(i32, bool) as KnownTuple>::FnPointer, fn(i32, bool)

Required Methods

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

Convert ref of tuple to tuple of refs.

let _: (&i8, &String) = (1, "hello".to_string()).as_tuple_of_refs();

Implementations on Foreign Types

impl<'a> KnownTuple<'a> for ()

type RefTuple = ()

type FnPointer = fn()

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a> KnownTuple<'a> for (A1,)

type RefTuple = (&'a A1,)

type FnPointer = fn(A1)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a> KnownTuple<'a> for (A1, A2)

type RefTuple = (&'a A1, &'a A2)

type FnPointer = fn(A1, A2)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a> KnownTuple<'a> for (A1, A2, A3)

type RefTuple = (&'a A1, &'a A2, &'a A3)

type FnPointer = fn(A1, A2, A3)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a> KnownTuple<'a> for (A1, A2, A3, A4)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4)

type FnPointer = fn(A1, A2, A3, A4)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5)

type FnPointer = fn(A1, A2, A3, A4, A5)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6)

type FnPointer = fn(A1, A2, A3, A4, A5, A6)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a, A9: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8, A9)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8, &'a A9)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8, A9)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a, A9: 'a, A10: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8, &'a A9, &'a A10)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a, A9: 'a, A10: 'a, A11: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8, &'a A9, &'a A10, &'a A11)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a, A9: 'a, A10: 'a, A11: 'a, A12: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8, &'a A9, &'a A10, &'a A11, &'a A12)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a, A9: 'a, A10: 'a, A11: 'a, A12: 'a, A13: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8, &'a A9, &'a A10, &'a A11, &'a A12, &'a A13)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a, A9: 'a, A10: 'a, A11: 'a, A12: 'a, A13: 'a, A14: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8, &'a A9, &'a A10, &'a A11, &'a A12, &'a A13, &'a A14)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

impl<'a, A1: 'a, A2: 'a, A3: 'a, A4: 'a, A5: 'a, A6: 'a, A7: 'a, A8: 'a, A9: 'a, A10: 'a, A11: 'a, A12: 'a, A13: 'a, A14: 'a, A15: 'a> KnownTuple<'a> for (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)

type RefTuple = (&'a A1, &'a A2, &'a A3, &'a A4, &'a A5, &'a A6, &'a A7, &'a A8, &'a A9, &'a A10, &'a A11, &'a A12, &'a A13, &'a A14, &'a A15)

type FnPointer = fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)

fn as_tuple_of_refs(&'a self) -> Self::RefTuple

Implementors