Trait rune::module::Function

pub trait Function<A, K>: 'static + Send + Sync { }

Trait used to provide the function function.

Object Safety

This trait is not object safe.

Implementors

impl<T, U> Function<(), Async> for T

where T: 'static + Send + Sync + Fn() -> U, U: 'static + Future, U::Output: ToValue,

impl<T, U> Function<(), Plain> for T

where T: 'static + Send + Sync + Fn() -> U, U: ToValue,

impl<T, U, A> Function<(Mut<A>,), Async> for T

where T: 'static + Send + Sync + Fn(&mut A) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut,

impl<T, U, A> Function<(Mut<A>,), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A) -> U, U: ToValue, A: ?Sized + UnsafeToMut,

impl<T, U, A> Function<(Ref<A>,), Async> for T

where T: 'static + Send + Sync + Fn(&A) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef,

impl<T, U, A> Function<(Ref<A>,), Plain> for T

where T: 'static + Send + Sync + Fn(&A) -> U, U: ToValue, A: ?Sized + UnsafeToRef,

impl<T, U, A> Function<(A,), Async> for T

where T: 'static + Send + Sync + Fn(A) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue,

impl<T, U, A> Function<(A,), Plain> for T

where T: 'static + Send + Sync + Fn(A) -> U, U: ToValue, A: FromValue,

impl<T, U, A, B> Function<(A, Mut<B>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut,

impl<T, U, A, B> Function<(A, Mut<B>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut,

impl<T, U, A, B> Function<(A, Ref<B>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef,

impl<T, U, A, B> Function<(A, Ref<B>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef,

impl<T, U, A, B> Function<(Mut<A>, B), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue,

impl<T, U, A, B> Function<(Mut<A>, B), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue,

impl<T, U, A, B> Function<(Mut<A>, Mut<B>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut,

impl<T, U, A, B> Function<(Mut<A>, Mut<B>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut,

impl<T, U, A, B> Function<(Mut<A>, Ref<B>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef,

impl<T, U, A, B> Function<(Mut<A>, Ref<B>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef,

impl<T, U, A, B> Function<(Ref<A>, B), Async> for T

where T: 'static + Send + Sync + Fn(&A, B) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue,

impl<T, U, A, B> Function<(Ref<A>, B), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue,

impl<T, U, A, B> Function<(Ref<A>, Mut<B>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut,

impl<T, U, A, B> Function<(Ref<A>, Mut<B>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut,

impl<T, U, A, B> Function<(Ref<A>, Ref<B>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef,

impl<T, U, A, B> Function<(Ref<A>, Ref<B>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef,

impl<T, U, A, B> Function<(A, B), Async> for T

where T: 'static + Send + Sync + Fn(A, B) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue,

impl<T, U, A, B> Function<(A, B), Plain> for T

where T: 'static + Send + Sync + Fn(A, B) -> U, U: ToValue, A: FromValue, B: FromValue,

impl<T, U, A, B, C> Function<(A, B, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(A, B, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(A, B, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(A, B, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(A, Mut<B>, C), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue,

impl<T, U, A, B, C> Function<(A, Mut<B>, C), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue,

impl<T, U, A, B, C> Function<(A, Mut<B>, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(A, Mut<B>, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(A, Mut<B>, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(A, Mut<B>, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(A, Ref<B>, C), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue,

impl<T, U, A, B, C> Function<(A, Ref<B>, C), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue,

impl<T, U, A, B, C> Function<(A, Ref<B>, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(A, Ref<B>, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(A, Ref<B>, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(A, Ref<B>, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Mut<A>, B, C), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue,

impl<T, U, A, B, C> Function<(Mut<A>, B, C), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue,

impl<T, U, A, B, C> Function<(Mut<A>, B, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Mut<A>, B, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Mut<A>, B, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Mut<A>, B, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Mut<A>, Mut<B>, C), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue,

impl<T, U, A, B, C> Function<(Mut<A>, Mut<B>, C), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue,

impl<T, U, A, B, C> Function<(Mut<A>, Mut<B>, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Mut<A>, Mut<B>, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Mut<A>, Mut<B>, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Mut<A>, Mut<B>, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Mut<A>, Ref<B>, C), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue,

impl<T, U, A, B, C> Function<(Mut<A>, Ref<B>, C), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue,

impl<T, U, A, B, C> Function<(Mut<A>, Ref<B>, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Mut<A>, Ref<B>, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Mut<A>, Ref<B>, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Mut<A>, Ref<B>, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Ref<A>, B, C), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue,

impl<T, U, A, B, C> Function<(Ref<A>, B, C), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue,

impl<T, U, A, B, C> Function<(Ref<A>, B, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Ref<A>, B, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Ref<A>, B, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Ref<A>, B, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Ref<A>, Mut<B>, C), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue,

impl<T, U, A, B, C> Function<(Ref<A>, Mut<B>, C), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue,

impl<T, U, A, B, C> Function<(Ref<A>, Mut<B>, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Ref<A>, Mut<B>, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Ref<A>, Mut<B>, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Ref<A>, Mut<B>, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Ref<A>, Ref<B>, C), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue,

impl<T, U, A, B, C> Function<(Ref<A>, Ref<B>, C), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue,

impl<T, U, A, B, C> Function<(Ref<A>, Ref<B>, Mut<C>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Ref<A>, Ref<B>, Mut<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut,

impl<T, U, A, B, C> Function<(Ref<A>, Ref<B>, Ref<C>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(Ref<A>, Ref<B>, Ref<C>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef,

impl<T, U, A, B, C> Function<(A, B, C), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue,

impl<T, U, A, B, C> Function<(A, B, C), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue,

impl<T, U, A, B, C, D> Function<(A, B, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, B, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, B, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, B, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, B, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, B, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, B, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, B, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, B, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, B, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, B, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, B, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, B, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, B, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, B, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, B, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, C, D), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Mut<B>, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, C, D), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, Ref<B>, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, C, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, B, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, C, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, C, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, C, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, B, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, C, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, C, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, C, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, C, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, C, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, C, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Mut<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Mut<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Ref<C>, D), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Ref<C>, D), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D> Function<(A, B, C, D), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, D) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D> Function<(A, B, C, D), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, D) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, &D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &mut C, &D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, &C, &D, &E) -> U, U: ToValue, A: FromValue, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, C, &D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &mut C, &D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Mut<B>, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &mut B, &C, &D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, C, &D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &mut C, &D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &mut D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D, E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D, &mut E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, Ref<B>, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(A, &B, &C, &D, &E) -> U, U: ToValue, A: FromValue, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &mut C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, B, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, B, &C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &mut C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Mut<B>, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &mut B, &C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &mut C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Mut<A>, Ref<B>, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&mut A, &B, &C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToMut, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &mut C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, B, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, B, &C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: FromValue, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &mut C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Mut<B>, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &mut B, &C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToMut, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, C, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: FromValue, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Mut<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &mut C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToMut, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, D, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, D, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, D, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, D, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, D, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: FromValue, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Mut<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &mut D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToMut, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>, E), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D, E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>, E), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D, E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>, Mut<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D, &mut E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>, Mut<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D, &mut E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToMut,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>, Ref<E>), Async> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D, &E) -> U, U: 'static + Future, U::Output: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(Ref<A>, Ref<B>, Ref<C>, Ref<D>, Ref<E>), Plain> for T

where T: 'static + Send + Sync + Fn(&A, &B, &C, &D, &E) -> U, U: ToValue, A: ?Sized + UnsafeToRef, B: ?Sized + UnsafeToRef, C: ?Sized + UnsafeToRef, D: ?Sized + UnsafeToRef, E: ?Sized + UnsafeToRef,

impl<T, U, A, B, C, D, E> Function<(A, B, C, D, E), Async> for T

where T: 'static + Send + Sync + Fn(A, B, C, D, E) -> U, U: 'static + Future, U::Output: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: FromValue,

impl<T, U, A, B, C, D, E> Function<(A, B, C, D, E), Plain> for T

where T: 'static + Send + Sync + Fn(A, B, C, D, E) -> U, U: ToValue, A: FromValue, B: FromValue, C: FromValue, D: FromValue, E: FromValue,