Struct fn_meta::FnMetadata

pub struct FnMetadata<Fun, Ret, ArgRefs>(pub PhantomData<(Fun, Ret, ArgRefs)>);

Metadata about a function

Tuple Fields

0: PhantomData<(Fun, Ret, ArgRefs)>

Implementations

impl<Fun, Ret> FnMetadata<Fun, Ret, ()> where
    Fun: FnOnce() -> Ret, 

pub fn borrows() -> [TypeId; 0]

pub fn borrow_muts() -> [TypeId; 0]

impl<Fun, Ret, A0> FnMetadata<Fun, Ret, (&A0,)> where
    A0: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 0]

impl<Fun, Ret, A0> FnMetadata<Fun, Ret, (&mut A0,)> where
    A0: 'static, 

pub fn borrows() -> [TypeId; 0]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1> FnMetadata<Fun, Ret, (&A0, &A1)> where
    A0: 'static,
    A1: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 0]

impl<Fun, Ret, A0, A1> FnMetadata<Fun, Ret, (&mut A0, &A1)> where
    A0: 'static,
    A1: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1> FnMetadata<Fun, Ret, (&A0, &mut A1)> where
    A0: 'static,
    A1: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1> FnMetadata<Fun, Ret, (&mut A0, &mut A1)> where
    A0: 'static,
    A1: 'static, 

pub fn borrows() -> [TypeId; 0]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&A0, &A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 0]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

pub fn borrows() -> [TypeId; 0]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 0]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

pub fn borrows() -> [TypeId; 0]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 5]

pub fn borrow_muts() -> [TypeId; 0]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

pub fn borrows() -> [TypeId; 0]

pub fn borrow_muts() -> [TypeId; 5]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 6]

pub fn borrow_muts() -> [TypeId; 0]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 5]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 5]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 5]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 5]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 5]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 5]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 5]

pub fn borrow_muts() -> [TypeId; 1]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 5]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 4]

pub fn borrow_muts() -> [TypeId; 2]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 5]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 3]

pub fn borrow_muts() -> [TypeId; 3]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 5]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 2]

pub fn borrow_muts() -> [TypeId; 4]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 5]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 1]

pub fn borrow_muts() -> [TypeId; 5]

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

pub fn borrows() -> [TypeId; 0]

pub fn borrow_muts() -> [TypeId; 6]

Trait Implementations

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMeta for FnMetadata<Fun, Ret, (&A0, &A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMeta for FnMetadata<Fun, Ret, (&A0, &mut A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0> FnMeta for FnMetadata<Fun, Ret, (&A0,)> where
    A0: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMeta for FnMetadata<Fun, Ret, (&mut A0, &mut A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0> FnMeta for FnMetadata<Fun, Ret, (&mut A0,)> where
    A0: 'static, 

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret> FnMeta for FnMetadata<Fun, Ret, ()>

fn borrows() -> TypeIds where
    Self: Sized, 

Returns the TypeIds of borrowed arguments.

fn borrow_muts() -> TypeIds where
    Self: Sized, 

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMetaDyn for FnMetadata<Fun, Ret, (&A0, &mut A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0> FnMetaDyn for FnMetadata<Fun, Ret, (&A0,)> where
    A0: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static,
    A5: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static,
    A4: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2, A3> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3)> where
    A0: 'static,
    A1: 'static,
    A2: 'static,
    A3: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1, A2> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1, &mut A2)> where
    A0: 'static,
    A1: 'static,
    A2: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0, A1> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0, &mut A1)> where
    A0: 'static,
    A1: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret, A0> FnMetaDyn for FnMetadata<Fun, Ret, (&mut A0,)> where
    A0: 'static, 

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.

impl<Fun, Ret> FnMetaDyn for FnMetadata<Fun, Ret, ()>

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.

fn borrow_muts(&self) -> TypeIds

Returns the TypeIds of mutably borrowed arguments.