Struct FnResource

pub struct FnResource<Fun, Ret, Args> {
    pub func: Fun,
    /* private fields */
}

Function that gets its arguments / parameters from a Resources map.

Fields

func: Fun

The actual function.

Implementations

impl<Fun, Ret> FnResource<Fun, Ret, ()>

where Fun: Fn() -> Ret + 'static, Ret: 'static,

pub fn call(&self, _resources: &Resources) -> Ret

pub fn try_call(&self, _resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0> FnResource<Fun, Ret, (&A0,)>

where Fun: Fn(&A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0> FnResource<Fun, Ret, (&mut A0,)>

where Fun: Fn(&mut A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1> FnResource<Fun, Ret, (&A0, &A1)>

where Fun: Fn(&A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1> FnResource<Fun, Ret, (&mut A0, &A1)>

where Fun: Fn(&mut A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1> FnResource<Fun, Ret, (&A0, &mut A1)>

where Fun: Fn(&A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1> FnResource<Fun, Ret, (&mut A0, &mut A1)>

where Fun: Fn(&mut A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&A0, &A1, &A2)>

where Fun: Fn(&A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&mut A0, &A1, &A2)>

where Fun: Fn(&mut A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&A0, &mut A1, &A2)>

where Fun: Fn(&A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2)>

where Fun: Fn(&mut A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&A0, &A1, &mut A2)>

where Fun: Fn(&A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2)>

where Fun: Fn(&mut A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2)>

where Fun: Fn(&A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2)>

where Fun: Fn(&mut A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &A1, &A2, &A3)>

where Fun: Fn(&A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3)>

where Fun: Fn(&mut A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3)>

where Fun: Fn(&A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3)>

where Fun: Fn(&A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3)>

where Fun: Fn(&A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4)>

where Fun: Fn(&A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4)>

where Fun: Fn(&A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

pub fn call(&self, resources: &Resources) -> Ret

pub fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Trait Implementations

impl<Fun, Ret, A0> FnMeta for FnResource<Fun, Ret, (&A0,)>

where Fun: FnOnce(&A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1)>

where Fun: FnOnce(&A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2)>

where Fun: FnOnce(&A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3)>

where Fun: FnOnce(&A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2)>

where Fun: FnOnce(&A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1)>

where Fun: FnOnce(&A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2)>

where Fun: FnOnce(&A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2)>

where Fun: FnOnce(&A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0,)>

where Fun: FnOnce(&mut A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1)>

where Fun: FnOnce(&mut A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2)>

where Fun: FnOnce(&mut A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2)>

where Fun: FnOnce(&mut A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1)>

where Fun: FnOnce(&mut A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2)>

where Fun: FnOnce(&mut A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, ()>

where Fun: FnOnce() -> Ret + 'static, Ret: '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> FnMetaDyn for FnResource<Fun, Ret, (&A0,)>

where Fun: FnOnce(&A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1)>

where Fun: FnOnce(&A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2)>

where Fun: FnOnce(&A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3)>

where Fun: FnOnce(&A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2)>

where Fun: FnOnce(&A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1)>

where Fun: FnOnce(&A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2)>

where Fun: FnOnce(&A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2)>

where Fun: FnOnce(&A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0,)>

where Fun: FnOnce(&mut A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1)>

where Fun: FnOnce(&mut A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2)>

where Fun: FnOnce(&mut A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2)>

where Fun: FnOnce(&mut A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1)>

where Fun: FnOnce(&mut A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2)>

where Fun: FnOnce(&mut A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: FnOnce(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + '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 FnResource<Fun, Ret, ()>

where Fun: FnOnce() -> Ret + 'static, Ret: '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> FnRes for FnResource<Fun, Ret, (&A0,)>

where Fun: Fn(&A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1> FnRes for FnResource<Fun, Ret, (&A0, &A1)>

where Fun: Fn(&A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2)>

where Fun: Fn(&A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &A3)>

where Fun: Fn(&A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4)>

where Fun: Fn(&A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4)>

where Fun: Fn(&A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3)>

where Fun: Fn(&A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2)>

where Fun: Fn(&A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3)>

where Fun: Fn(&A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1> FnRes for FnResource<Fun, Ret, (&A0, &mut A1)>

where Fun: Fn(&A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2)>

where Fun: Fn(&A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3)>

where Fun: Fn(&A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2)>

where Fun: Fn(&A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0> FnRes for FnResource<Fun, Ret, (&mut A0,)>

where Fun: Fn(&mut A0) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1> FnRes for FnResource<Fun, Ret, (&mut A0, &A1)>

where Fun: Fn(&mut A0, &A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2)>

where Fun: Fn(&mut A0, &A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3)>

where Fun: Fn(&mut A0, &A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2)>

where Fun: Fn(&mut A0, &A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1)>

where Fun: Fn(&mut A0, &mut A1) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2)>

where Fun: Fn(&mut A0, &mut A1, &A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2)>

where Fun: Fn(&mut A0, &mut A1, &mut A2) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret, A0, A1, A2, A3, A4, A5> FnRes for FnResource<Fun, Ret, (&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5)>

where Fun: Fn(&mut A0, &mut A1, &mut A2, &mut A3, &mut A4, &mut A5) -> Ret + 'static, Ret: 'static, A0: Debug + Send + Sync + 'static, A1: Debug + Send + Sync + 'static, A2: Debug + Send + Sync + 'static, A3: Debug + Send + Sync + 'static, A4: Debug + Send + Sync + 'static, A5: Debug + Send + Sync + 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.

impl<Fun, Ret> FnRes for FnResource<Fun, Ret, ()>

where Fun: Fn() -> Ret + 'static, Ret: 'static,

type Ret = Ret

Return type of the function.

fn call(&self, resources: &Resources) -> Ret

Runs the function.

fn try_call(&self, resources: &Resources) -> Result<Ret, BorrowFail>

Runs the function.