Trait BuildFn 

pub trait BuildFn<Safety = Safe, Abi = Rust, Output = ()>: Tuple {
    type F: FnPtr<Args = Self, Output = Output, Safety = Safety, Abi = Abi>;
}

Constructs a function-pointer type from its components.

Given

• a tuple of argument types (Self)
• a safety marker (Safety)
• an abi (Abi)
• an output type (Output)

The trait is implemented for tuples, which get turned into the parameter types of F.

Examples

use fn_ptr::{BuildFn, safety, abi};
type F0 = <(i32,) as BuildFn>::F; // fn(i32)
type F1 = <() as BuildFn<safety::Unsafe, abi::Rust, u64>>::F; // unsafe fn() -> u64
type F2 = <(String, f32) as BuildFn<safety::Safe, abi::C, i32>>::F; // extern "C" fn(String, f32) -> i32

Required Associated Types

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

The resulting function-pointer type.

Implementations on Foreign Types

impl<Output> BuildFn<Safe, C, Output> for ()

type F = extern "C" fn() -> Output

impl<Output> BuildFn<Safe, CUnwind, Output> for ()

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

impl<Output> BuildFn<Safe, EfiApi, Output> for ()

type F = extern "efiapi" fn() -> Output

impl<Output> BuildFn<Safe, Rust, Output> for ()

type F = fn() -> Output

impl<Output> BuildFn<Safe, SysV64, Output> for ()

type F = extern "sysv64" fn() -> Output

impl<Output> BuildFn<Safe, SysV64Unwind, Output> for ()

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

impl<Output> BuildFn<Safe, System, Output> for ()

type F = extern "system" fn() -> Output

impl<Output> BuildFn<Safe, SystemUnwind, Output> for ()

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

impl<Output> BuildFn<Unsafe, C, Output> for ()

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

impl<Output> BuildFn<Unsafe, CUnwind, Output> for ()

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

impl<Output> BuildFn<Unsafe, EfiApi, Output> for ()

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

impl<Output> BuildFn<Unsafe, Rust, Output> for ()

type F = unsafe fn() -> Output

impl<Output> BuildFn<Unsafe, SysV64, Output> for ()

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

impl<Output> BuildFn<Unsafe, SysV64Unwind, Output> for ()

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

impl<Output> BuildFn<Unsafe, System, Output> for ()

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

impl<Output> BuildFn<Unsafe, SystemUnwind, Output> for ()

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

impl<Output, A> BuildFn<Safe, C, Output> for (A,)

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

impl<Output, A> BuildFn<Safe, CUnwind, Output> for (A,)

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

impl<Output, A> BuildFn<Safe, EfiApi, Output> for (A,)

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

impl<Output, A> BuildFn<Safe, Rust, Output> for (A,)

type F = fn(A) -> Output

impl<Output, A> BuildFn<Safe, SysV64, Output> for (A,)

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

impl<Output, A> BuildFn<Safe, SysV64Unwind, Output> for (A,)

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

impl<Output, A> BuildFn<Safe, System, Output> for (A,)

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

impl<Output, A> BuildFn<Safe, SystemUnwind, Output> for (A,)

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

impl<Output, A> BuildFn<Unsafe, C, Output> for (A,)

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

impl<Output, A> BuildFn<Unsafe, CUnwind, Output> for (A,)

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

impl<Output, A> BuildFn<Unsafe, EfiApi, Output> for (A,)

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

impl<Output, A> BuildFn<Unsafe, Rust, Output> for (A,)

type F = unsafe fn(A) -> Output

impl<Output, A> BuildFn<Unsafe, SysV64, Output> for (A,)

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

impl<Output, A> BuildFn<Unsafe, SysV64Unwind, Output> for (A,)

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

impl<Output, A> BuildFn<Unsafe, System, Output> for (A,)

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

impl<Output, A> BuildFn<Unsafe, SystemUnwind, Output> for (A,)

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

impl<Output, A, B> BuildFn<Safe, C, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Safe, CUnwind, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Safe, EfiApi, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Safe, Rust, Output> for (A, B)

type F = fn(A, B) -> Output

impl<Output, A, B> BuildFn<Safe, SysV64, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Safe, SysV64Unwind, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Safe, System, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Safe, SystemUnwind, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, C, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, CUnwind, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, EfiApi, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, Rust, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, SysV64, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, SysV64Unwind, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, System, Output> for (A, B)

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

impl<Output, A, B> BuildFn<Unsafe, SystemUnwind, Output> for (A, B)

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

impl<Output, A, B, C> BuildFn<Safe, C, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Safe, CUnwind, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Safe, EfiApi, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Safe, Rust, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Safe, SysV64, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Safe, SysV64Unwind, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Safe, System, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Safe, SystemUnwind, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, C, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, CUnwind, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, EfiApi, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, Rust, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, SysV64, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, SysV64Unwind, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, System, Output> for (A, B, C)

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

impl<Output, A, B, C> BuildFn<Unsafe, SystemUnwind, Output> for (A, B, C)

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

impl<Output, A, B, C, D> BuildFn<Safe, C, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Safe, CUnwind, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Safe, EfiApi, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Safe, Rust, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Safe, SysV64, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Safe, SysV64Unwind, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Safe, System, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Safe, SystemUnwind, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, C, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, CUnwind, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, EfiApi, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, Rust, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, SysV64, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, SysV64Unwind, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, System, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D> BuildFn<Unsafe, SystemUnwind, Output> for (A, B, C, D)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, C, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, CUnwind, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, EfiApi, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, Rust, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, SysV64, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, SysV64Unwind, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, System, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Safe, SystemUnwind, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, C, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, CUnwind, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, EfiApi, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, Rust, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, SysV64, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, SysV64Unwind, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, System, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E> BuildFn<Unsafe, SystemUnwind, Output> for (A, B, C, D, E)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, C, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, CUnwind, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, EfiApi, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, Rust, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, SysV64, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, SysV64Unwind, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, System, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Safe, SystemUnwind, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, C, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, CUnwind, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, EfiApi, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, Rust, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, SysV64, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, SysV64Unwind, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, System, Output> for (A, B, C, D, E, F)

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

impl<Output, A, B, C, D, E, F> BuildFn<Unsafe, SystemUnwind, Output> for (A, B, C, D, E, F)

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

Implementors