Struct resman::FnResource

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

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

Fields§

§func: Fun

The actual function.

Implementations§

source§

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

source

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

source

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.
source§

impl<Fun, Ret> FnMeta for FnResource<Fun, Ret, ()>where Fun: FnOnce() -> Ret + 'static, Ret: 'static,

source§

fn borrows() -> TypeIds

Returns the TypeIds of borrowed arguments.
source§

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.
source§

impl<Fun, Ret> FnMetaDyn for FnResource<Fun, Ret, ()>where Fun: FnOnce() -> Ret + 'static, Ret: 'static,

source§

fn borrows(&self) -> TypeIds

Returns the TypeIds of borrowed arguments.
source§

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.
source§

impl<Fun, Ret> FnRes for FnResource<Fun, Ret, ()>where Fun: Fn() -> Ret + 'static, Ret: 'static,

§

type Ret = Ret

Return type of the function.
source§

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

Runs the function.
source§

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

Runs the function.

Auto Trait Implementations§

§

impl<Fun, Ret, Args> RefUnwindSafe for FnResource<Fun, Ret, Args>where Args: RefUnwindSafe, Fun: RefUnwindSafe, Ret: RefUnwindSafe,

§

impl<Fun, Ret, Args> Send for FnResource<Fun, Ret, Args>where Args: Send, Fun: Send, Ret: Send,

§

impl<Fun, Ret, Args> Sync for FnResource<Fun, Ret, Args>where Args: Sync, Fun: Sync, Ret: Sync,

§

impl<Fun, Ret, Args> Unpin for FnResource<Fun, Ret, Args>where Args: Unpin, Fun: Unpin, Ret: Unpin,

§

impl<Fun, Ret, Args> UnwindSafe for FnResource<Fun, Ret, Args>where Args: UnwindSafe, Fun: UnwindSafe, Ret: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Downcast for Twhere T: Any,

source§

fn into_any(self: Box<T, Global>) -> Box<dyn Any, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
source§

fn into_any_rc(self: Rc<T, Global>) -> Rc<dyn Any, Global>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> DowncastSync for Twhere T: Any + Send + Sync,

source§

fn into_any_arc(self: Arc<T, Global>) -> Arc<dyn Any + Send + Sync, Global>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.