Trait WithOutputImpl 

pub trait WithOutputImpl<F: FnPtr = Self> {
    type F<T>: FnPtr<Args = F::Args, Output = T, Safety = F::Safety, Abi = F::Abi>;
}

Helper trait used by WithOutput (use it instead). This trait is required to allow FnPtr to be a subtrait of WithOutput, which eliminates the need for a type bound when using a fixed output type. Using WithOutput directly would result in a cyclic supertrait error.

Required Associated Types

type F<T>: FnPtr<Args = F::Args, Output = T, Safety = F::Safety, Abi = F::Abi>

The function pointer type with the requested output type (preserving all other properties).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Output, A, B, C, D, E, F> WithOutputImpl for extern "C" fn(A, B, C, D, E, F) -> Output

type F<R> = extern "C" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F<R> = extern "C-unwind" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F<R> = extern "efiapi" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for extern "system" fn(A, B, C, D, E, F) -> Output

type F<R> = extern "system" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F<R> = extern "system-unwind" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F<R> = extern "sysv64" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F<R> = extern "sysv64-unwind" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for fn(A, B, C, D, E, F) -> Output

type F<R> = fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe extern "C" fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe extern "C" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe extern "efiapi" fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe extern "efiapi" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe extern "system" fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe extern "system" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe extern "system-unwind" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe extern "sysv64" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe extern "sysv64-unwind" fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E, F> WithOutputImpl for unsafe fn(A, B, C, D, E, F) -> Output

type F<R> = unsafe fn(A, B, C, D, E, F) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for extern "C" fn(A, B, C, D, E) -> Output

type F<R> = extern "C" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for extern "C-unwind" fn(A, B, C, D, E) -> Output

type F<R> = extern "C-unwind" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for extern "efiapi" fn(A, B, C, D, E) -> Output

type F<R> = extern "efiapi" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for extern "system" fn(A, B, C, D, E) -> Output

type F<R> = extern "system" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for extern "system-unwind" fn(A, B, C, D, E) -> Output

type F<R> = extern "system-unwind" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for extern "sysv64" fn(A, B, C, D, E) -> Output

type F<R> = extern "sysv64" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F<R> = extern "sysv64-unwind" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for fn(A, B, C, D, E) -> Output

type F<R> = fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe extern "C" fn(A, B, C, D, E) -> Output

type F<R> = unsafe extern "C" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Output

type F<R> = unsafe extern "C-unwind" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe extern "efiapi" fn(A, B, C, D, E) -> Output

type F<R> = unsafe extern "efiapi" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe extern "system" fn(A, B, C, D, E) -> Output

type F<R> = unsafe extern "system" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe extern "system-unwind" fn(A, B, C, D, E) -> Output

type F<R> = unsafe extern "system-unwind" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe extern "sysv64" fn(A, B, C, D, E) -> Output

type F<R> = unsafe extern "sysv64" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> Output

type F<R> = unsafe extern "sysv64-unwind" fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D, E> WithOutputImpl for unsafe fn(A, B, C, D, E) -> Output

type F<R> = unsafe fn(A, B, C, D, E) -> R

impl<Output, A, B, C, D> WithOutputImpl for extern "C" fn(A, B, C, D) -> Output

type F<R> = extern "C" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for extern "C-unwind" fn(A, B, C, D) -> Output

type F<R> = extern "C-unwind" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for extern "efiapi" fn(A, B, C, D) -> Output

type F<R> = extern "efiapi" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for extern "system" fn(A, B, C, D) -> Output

type F<R> = extern "system" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for extern "system-unwind" fn(A, B, C, D) -> Output

type F<R> = extern "system-unwind" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for extern "sysv64" fn(A, B, C, D) -> Output

type F<R> = extern "sysv64" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F<R> = extern "sysv64-unwind" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for fn(A, B, C, D) -> Output

type F<R> = fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe extern "C" fn(A, B, C, D) -> Output

type F<R> = unsafe extern "C" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe extern "C-unwind" fn(A, B, C, D) -> Output

type F<R> = unsafe extern "C-unwind" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe extern "efiapi" fn(A, B, C, D) -> Output

type F<R> = unsafe extern "efiapi" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe extern "system" fn(A, B, C, D) -> Output

type F<R> = unsafe extern "system" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe extern "system-unwind" fn(A, B, C, D) -> Output

type F<R> = unsafe extern "system-unwind" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe extern "sysv64" fn(A, B, C, D) -> Output

type F<R> = unsafe extern "sysv64" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe extern "sysv64-unwind" fn(A, B, C, D) -> Output

type F<R> = unsafe extern "sysv64-unwind" fn(A, B, C, D) -> R

impl<Output, A, B, C, D> WithOutputImpl for unsafe fn(A, B, C, D) -> Output

type F<R> = unsafe fn(A, B, C, D) -> R

impl<Output, A, B, C> WithOutputImpl for extern "C" fn(A, B, C) -> Output

type F<R> = extern "C" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for extern "C-unwind" fn(A, B, C) -> Output

type F<R> = extern "C-unwind" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for extern "efiapi" fn(A, B, C) -> Output

type F<R> = extern "efiapi" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for extern "system" fn(A, B, C) -> Output

type F<R> = extern "system" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for extern "system-unwind" fn(A, B, C) -> Output

type F<R> = extern "system-unwind" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for extern "sysv64" fn(A, B, C) -> Output

type F<R> = extern "sysv64" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for extern "sysv64-unwind" fn(A, B, C) -> Output

type F<R> = extern "sysv64-unwind" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for fn(A, B, C) -> Output

type F<R> = fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe extern "C" fn(A, B, C) -> Output

type F<R> = unsafe extern "C" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe extern "C-unwind" fn(A, B, C) -> Output

type F<R> = unsafe extern "C-unwind" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe extern "efiapi" fn(A, B, C) -> Output

type F<R> = unsafe extern "efiapi" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe extern "system" fn(A, B, C) -> Output

type F<R> = unsafe extern "system" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe extern "system-unwind" fn(A, B, C) -> Output

type F<R> = unsafe extern "system-unwind" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe extern "sysv64" fn(A, B, C) -> Output

type F<R> = unsafe extern "sysv64" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe extern "sysv64-unwind" fn(A, B, C) -> Output

type F<R> = unsafe extern "sysv64-unwind" fn(A, B, C) -> R

impl<Output, A, B, C> WithOutputImpl for unsafe fn(A, B, C) -> Output

type F<R> = unsafe fn(A, B, C) -> R

impl<Output, A, B> WithOutputImpl for extern "C" fn(A, B) -> Output

type F<R> = extern "C" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for extern "C-unwind" fn(A, B) -> Output

type F<R> = extern "C-unwind" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for extern "efiapi" fn(A, B) -> Output

type F<R> = extern "efiapi" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for extern "system" fn(A, B) -> Output

type F<R> = extern "system" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for extern "system-unwind" fn(A, B) -> Output

type F<R> = extern "system-unwind" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for extern "sysv64" fn(A, B) -> Output

type F<R> = extern "sysv64" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for extern "sysv64-unwind" fn(A, B) -> Output

type F<R> = extern "sysv64-unwind" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for fn(A, B) -> Output

type F<R> = fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe extern "C" fn(A, B) -> Output

type F<R> = unsafe extern "C" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe extern "C-unwind" fn(A, B) -> Output

type F<R> = unsafe extern "C-unwind" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe extern "efiapi" fn(A, B) -> Output

type F<R> = unsafe extern "efiapi" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe extern "system" fn(A, B) -> Output

type F<R> = unsafe extern "system" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe extern "system-unwind" fn(A, B) -> Output

type F<R> = unsafe extern "system-unwind" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe extern "sysv64" fn(A, B) -> Output

type F<R> = unsafe extern "sysv64" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe extern "sysv64-unwind" fn(A, B) -> Output

type F<R> = unsafe extern "sysv64-unwind" fn(A, B) -> R

impl<Output, A, B> WithOutputImpl for unsafe fn(A, B) -> Output

type F<R> = unsafe fn(A, B) -> R

impl<Output, A> WithOutputImpl for extern "C" fn(A) -> Output

type F<R> = extern "C" fn(A) -> R

impl<Output, A> WithOutputImpl for extern "C-unwind" fn(A) -> Output

type F<R> = extern "C-unwind" fn(A) -> R

impl<Output, A> WithOutputImpl for extern "efiapi" fn(A) -> Output

type F<R> = extern "efiapi" fn(A) -> R

impl<Output, A> WithOutputImpl for extern "system" fn(A) -> Output

type F<R> = extern "system" fn(A) -> R

impl<Output, A> WithOutputImpl for extern "system-unwind" fn(A) -> Output

type F<R> = extern "system-unwind" fn(A) -> R

impl<Output, A> WithOutputImpl for extern "sysv64" fn(A) -> Output

type F<R> = extern "sysv64" fn(A) -> R

impl<Output, A> WithOutputImpl for extern "sysv64-unwind" fn(A) -> Output

type F<R> = extern "sysv64-unwind" fn(A) -> R

impl<Output, A> WithOutputImpl for fn(A) -> Output

type F<R> = fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe extern "C" fn(A) -> Output

type F<R> = unsafe extern "C" fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe extern "C-unwind" fn(A) -> Output

type F<R> = unsafe extern "C-unwind" fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe extern "efiapi" fn(A) -> Output

type F<R> = unsafe extern "efiapi" fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe extern "system" fn(A) -> Output

type F<R> = unsafe extern "system" fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe extern "system-unwind" fn(A) -> Output

type F<R> = unsafe extern "system-unwind" fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe extern "sysv64" fn(A) -> Output

type F<R> = unsafe extern "sysv64" fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe extern "sysv64-unwind" fn(A) -> Output

type F<R> = unsafe extern "sysv64-unwind" fn(A) -> R

impl<Output, A> WithOutputImpl for unsafe fn(A) -> Output

type F<R> = unsafe fn(A) -> R

impl<Output> WithOutputImpl for extern "C" fn() -> Output

type F<R> = extern "C" fn() -> R

impl<Output> WithOutputImpl for extern "C-unwind" fn() -> Output

type F<R> = extern "C-unwind" fn() -> R

impl<Output> WithOutputImpl for extern "efiapi" fn() -> Output

type F<R> = extern "efiapi" fn() -> R

impl<Output> WithOutputImpl for extern "system" fn() -> Output

type F<R> = extern "system" fn() -> R

impl<Output> WithOutputImpl for extern "system-unwind" fn() -> Output

type F<R> = extern "system-unwind" fn() -> R

impl<Output> WithOutputImpl for extern "sysv64" fn() -> Output

type F<R> = extern "sysv64" fn() -> R

impl<Output> WithOutputImpl for extern "sysv64-unwind" fn() -> Output

type F<R> = extern "sysv64-unwind" fn() -> R

impl<Output> WithOutputImpl for fn() -> Output

type F<R> = fn() -> R

impl<Output> WithOutputImpl for unsafe extern "C" fn() -> Output

type F<R> = unsafe extern "C" fn() -> R

impl<Output> WithOutputImpl for unsafe extern "C-unwind" fn() -> Output

type F<R> = unsafe extern "C-unwind" fn() -> R

impl<Output> WithOutputImpl for unsafe extern "efiapi" fn() -> Output

type F<R> = unsafe extern "efiapi" fn() -> R

impl<Output> WithOutputImpl for unsafe extern "system" fn() -> Output

type F<R> = unsafe extern "system" fn() -> R

impl<Output> WithOutputImpl for unsafe extern "system-unwind" fn() -> Output

type F<R> = unsafe extern "system-unwind" fn() -> R

impl<Output> WithOutputImpl for unsafe extern "sysv64" fn() -> Output

type F<R> = unsafe extern "sysv64" fn() -> R

impl<Output> WithOutputImpl for unsafe extern "sysv64-unwind" fn() -> Output

type F<R> = unsafe extern "sysv64-unwind" fn() -> R

impl<Output> WithOutputImpl for unsafe fn() -> Output

type F<R> = unsafe fn() -> R

Implementors