Trait WithAbi 

pub trait WithAbi<const ABI: Abi, F: FnPtr> {
    type F: FnPtr;
}

Computes the function pointer type obtained by changing the ABI while preserving arity, arguments, return type, and safety.

Required Associated Types

type F: FnPtr

The function pointer type with the requested ABI (preserving safety and signature).

Implementations on Foreign Types

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, fn() -> Ret> for fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, extern "C" fn() -> Ret> for extern "C" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, extern "system" fn() -> Ret> for extern "system" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, extern "sysv64" fn() -> Ret> for extern "sysv64" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, unsafe fn() -> Ret> for unsafe fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "system" fn() -> Ret> for unsafe extern "system" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "sysv64" fn() -> Ret> for unsafe extern "sysv64" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, fn() -> Ret> for fn() -> Ret

Available on crate feature nightly only.

type F = fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, extern "C" fn() -> Ret> for extern "C" fn() -> Ret

Available on crate feature nightly only.

type F = fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, extern "system" fn() -> Ret> for extern "system" fn() -> Ret

Available on crate feature nightly only.

type F = fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, extern "sysv64" fn() -> Ret> for extern "sysv64" fn() -> Ret

Available on crate feature nightly only.

type F = fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, unsafe fn() -> Ret> for unsafe fn() -> Ret

Available on crate feature nightly only.

type F = unsafe fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

Available on crate feature nightly only.

type F = unsafe fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "system" fn() -> Ret> for unsafe extern "system" fn() -> Ret

Available on crate feature nightly only.

type F = unsafe fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "sysv64" fn() -> Ret> for unsafe extern "sysv64" fn() -> Ret

Available on crate feature nightly only.

type F = unsafe fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, fn() -> Ret> for fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, extern "C" fn() -> Ret> for extern "C" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, extern "system" fn() -> Ret> for extern "system" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, extern "sysv64" fn() -> Ret> for extern "sysv64" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, unsafe fn() -> Ret> for unsafe fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "system" fn() -> Ret> for unsafe extern "system" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "sysv64" fn() -> Ret> for unsafe extern "sysv64" fn() -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, fn() -> Ret> for fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "C" fn() -> Ret> for extern "C" fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "system" fn() -> Ret> for extern "system" fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "sysv64" fn() -> Ret> for extern "sysv64" fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe fn() -> Ret> for unsafe fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "system" fn() -> Ret> for unsafe extern "system" fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "sysv64" fn() -> Ret> for unsafe extern "sysv64" fn() -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, fn(A) -> Ret> for fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, extern "system" fn(A) -> Ret> for extern "system" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, extern "sysv64" fn(A) -> Ret> for extern "sysv64" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "system" fn(A) -> Ret> for unsafe extern "system" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "sysv64" fn(A) -> Ret> for unsafe extern "sysv64" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, fn(A) -> Ret> for fn(A) -> Ret

Available on crate feature nightly only.

type F = fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret

Available on crate feature nightly only.

type F = fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, extern "system" fn(A) -> Ret> for extern "system" fn(A) -> Ret

Available on crate feature nightly only.

type F = fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, extern "sysv64" fn(A) -> Ret> for extern "sysv64" fn(A) -> Ret

Available on crate feature nightly only.

type F = fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret

Available on crate feature nightly only.

type F = unsafe fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

Available on crate feature nightly only.

type F = unsafe fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "system" fn(A) -> Ret> for unsafe extern "system" fn(A) -> Ret

Available on crate feature nightly only.

type F = unsafe fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "sysv64" fn(A) -> Ret> for unsafe extern "sysv64" fn(A) -> Ret

Available on crate feature nightly only.

type F = unsafe fn(A) -> Ret

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, fn(A) -> Ret> for fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, extern "system" fn(A) -> Ret> for extern "system" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, extern "sysv64" fn(A) -> Ret> for extern "sysv64" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "system" fn(A) -> Ret> for unsafe extern "system" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "sysv64" fn(A) -> Ret> for unsafe extern "sysv64" fn(A) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, fn(A) -> Ret> for fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "system" fn(A) -> Ret> for extern "system" fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "sysv64" fn(A) -> Ret> for extern "sysv64" fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "system" fn(A) -> Ret> for unsafe extern "system" fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "sysv64" fn(A) -> Ret> for unsafe extern "sysv64" fn(A) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, fn(A, B) -> Ret> for fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, extern "system" fn(A, B) -> Ret> for extern "system" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, extern "sysv64" fn(A, B) -> Ret> for extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "system" fn(A, B) -> Ret> for unsafe extern "system" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "sysv64" fn(A, B) -> Ret> for unsafe extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, fn(A, B) -> Ret> for fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, extern "system" fn(A, B) -> Ret> for extern "system" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, extern "sysv64" fn(A, B) -> Ret> for extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "system" fn(A, B) -> Ret> for unsafe extern "system" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "sysv64" fn(A, B) -> Ret> for unsafe extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, fn(A, B) -> Ret> for fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, extern "system" fn(A, B) -> Ret> for extern "system" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, extern "sysv64" fn(A, B) -> Ret> for extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "system" fn(A, B) -> Ret> for unsafe extern "system" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "sysv64" fn(A, B) -> Ret> for unsafe extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, fn(A, B) -> Ret> for fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "system" fn(A, B) -> Ret> for extern "system" fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "sysv64" fn(A, B) -> Ret> for extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "system" fn(A, B) -> Ret> for unsafe extern "system" fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "sysv64" fn(A, B) -> Ret> for unsafe extern "sysv64" fn(A, B) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, extern "system" fn(A, B, C) -> Ret> for extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, extern "sysv64" fn(A, B, C) -> Ret> for extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "system" fn(A, B, C) -> Ret> for unsafe extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "sysv64" fn(A, B, C) -> Ret> for unsafe extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, extern "system" fn(A, B, C) -> Ret> for extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, extern "sysv64" fn(A, B, C) -> Ret> for extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "system" fn(A, B, C) -> Ret> for unsafe extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "sysv64" fn(A, B, C) -> Ret> for unsafe extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, extern "system" fn(A, B, C) -> Ret> for extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, extern "sysv64" fn(A, B, C) -> Ret> for extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "system" fn(A, B, C) -> Ret> for unsafe extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "sysv64" fn(A, B, C) -> Ret> for unsafe extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "system" fn(A, B, C) -> Ret> for extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "sysv64" fn(A, B, C) -> Ret> for extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "system" fn(A, B, C) -> Ret> for unsafe extern "system" fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "sysv64" fn(A, B, C) -> Ret> for unsafe extern "sysv64" fn(A, B, C) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, extern "system" fn(A, B, C, D) -> Ret> for extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, extern "sysv64" fn(A, B, C, D) -> Ret> for extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "system" fn(A, B, C, D) -> Ret> for unsafe extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "sysv64" fn(A, B, C, D) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, extern "system" fn(A, B, C, D) -> Ret> for extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, extern "sysv64" fn(A, B, C, D) -> Ret> for extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "system" fn(A, B, C, D) -> Ret> for unsafe extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "sysv64" fn(A, B, C, D) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, extern "system" fn(A, B, C, D) -> Ret> for extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, extern "sysv64" fn(A, B, C, D) -> Ret> for extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "system" fn(A, B, C, D) -> Ret> for unsafe extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "sysv64" fn(A, B, C, D) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "system" fn(A, B, C, D) -> Ret> for extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "sysv64" fn(A, B, C, D) -> Ret> for extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "system" fn(A, B, C, D) -> Ret> for unsafe extern "system" fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "sysv64" fn(A, B, C, D) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, extern "system" fn(A, B, C, D, E) -> Ret> for extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, extern "sysv64" fn(A, B, C, D, E) -> Ret> for extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "system" fn(A, B, C, D, E) -> Ret> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, extern "system" fn(A, B, C, D, E) -> Ret> for extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, extern "sysv64" fn(A, B, C, D, E) -> Ret> for extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "system" fn(A, B, C, D, E) -> Ret> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, extern "system" fn(A, B, C, D, E) -> Ret> for extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, extern "sysv64" fn(A, B, C, D, E) -> Ret> for extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "system" fn(A, B, C, D, E) -> Ret> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "system" fn(A, B, C, D, E) -> Ret> for extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "sysv64" fn(A, B, C, D, E) -> Ret> for extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "system" fn(A, B, C, D, E) -> Ret> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, extern "system" fn(A, B, C, D, E, F) -> Ret> for extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "system" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::C}, unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, extern "system" fn(A, B, C, D, E, F) -> Ret> for extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "system" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Rust}, unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, extern "system" fn(A, B, C, D, E, F) -> Ret> for extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "system" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::System}, unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "system" fn(A, B, C, D, E, F) -> Ret> for extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "system" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> WithAbi<{$crate::Abi::Sysv64}, unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on crate feature nightly and has_abi_sysv64 only.

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

Implementors