Struct resman::FnResource[−][src]

pub struct FnResource<Fun, Ret, Args> {
    pub func: Fun,
    // some fields omitted
}

Expand description

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

Fields

func: Fun

The actual function.

Implementations

[src]

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

[src]

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

[src]

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

[src]

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

type Ret = Ret

Return type of the function.

[src]

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

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

Runs the function.

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,

[src]

pub 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. Read more

type Error = Infallible

The type returned in the event of a conversion error.

[src]

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

Performs the conversion.

[src]

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

type Error = >::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct resman::FnResource[−][src]

Fields

Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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> FnResource<Fun, Ret, ()> where
Fun: Fn() -> Ret + 'static,
Ret: 'static,

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

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

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,

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,