Trait WithAbi 

pub trait WithAbi<const ABI: u8> {
    type F: FnPtr + HasAbi<ABI>;
}

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

Required Associated Types

type F: FnPtr + HasAbi<ABI>

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

Implementations on Foreign Types

impl<Ret: 'static> WithAbi<{$crate::abi!("C")}> for fn() -> Ret

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<Ret: 'static> WithAbi<{$crate::abi!("Rust")}> for fn() -> Ret

type F = fn() -> Ret

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

type F = fn() -> Ret

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

type F = fn() -> Ret

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

type F = fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::abi!("Rust")}> for unsafe fn() -> Ret

type F = unsafe fn() -> Ret

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

type F = unsafe fn() -> Ret

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

type F = unsafe fn() -> Ret

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

type F = unsafe fn() -> Ret

impl<Ret: 'static> WithAbi<{$crate::abi!("system")}> for fn() -> Ret

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

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

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

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

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

impl<Ret: 'static> WithAbi<{$crate::abi!("system")}> for extern "sysv64" fn() -> Ret

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

impl<Ret: 'static> WithAbi<{$crate::abi!("system")}> for unsafe fn() -> Ret

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

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

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

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

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

impl<Ret: 'static> WithAbi<{$crate::abi!("system")}> for unsafe extern "sysv64" fn() -> Ret

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

impl<Ret: 'static> WithAbi<{$crate::abi!("sysv64")}> for fn() -> Ret

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::abi!("sysv64")}> for extern "system" fn() -> Ret

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::abi!("sysv64")}> for unsafe fn() -> Ret

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

impl<Ret: 'static> WithAbi<{$crate::abi!("sysv64")}> for unsafe extern "system" fn() -> Ret

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type F = fn(A) -> Ret

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

type F = fn(A) -> Ret

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

type F = fn(A) -> Ret

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

type F = fn(A) -> Ret

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

type F = unsafe fn(A) -> Ret

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

type F = unsafe fn(A) -> Ret

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

type F = unsafe fn(A) -> Ret

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

type F = unsafe fn(A) -> Ret

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on has_abi_sysv64 only.

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

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

Available on 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")}> for fn(A, B, C) -> Ret

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Available on 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")}> for extern "C" fn(A, B, C) -> Ret

Available on 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")}> for extern "system" fn(A, B, C) -> Ret

Available on 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")}> for extern "sysv64" fn(A, B, C) -> Ret

Available on 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")}> for unsafe fn(A, B, C) -> Ret

Available on 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")}> for unsafe extern "C" fn(A, B, C) -> Ret

Available on 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")}> for unsafe extern "system" fn(A, B, C) -> Ret

Available on 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")}> for unsafe extern "sysv64" fn(A, B, C) -> Ret

Available on 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")}> for fn(A, B, C, D) -> Ret

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")}> for extern "C" fn(A, B, C, D) -> Ret

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")}> for extern "system" fn(A, B, C, D) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D) -> Ret

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")}> for unsafe fn(A, B, C, D) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D) -> Ret

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")}> for fn(A, B, C, D) -> Ret

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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")}> for extern "C" fn(A, B, C, D) -> Ret

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")}> for extern "system" fn(A, B, C, D) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D) -> Ret

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")}> for unsafe fn(A, B, C, D) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D) -> Ret

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")}> for fn(A, B, C, D) -> Ret

Available on 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")}> for extern "C" fn(A, B, C, D) -> Ret

Available on 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")}> for extern "system" fn(A, B, C, D) -> Ret

Available on 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")}> for extern "sysv64" fn(A, B, C, D) -> Ret

Available on 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")}> for unsafe fn(A, B, C, D) -> Ret

Available on 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")}> for unsafe extern "C" fn(A, B, C, D) -> Ret

Available on 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")}> for unsafe extern "system" fn(A, B, C, D) -> Ret

Available on 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")}> for unsafe extern "sysv64" fn(A, B, C, D) -> Ret

Available on 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")}> for fn(A, B, C, D, E) -> Ret

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")}> for extern "C" fn(A, B, C, D, E) -> Ret

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")}> for extern "system" fn(A, B, C, D, E) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D, E) -> Ret

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")}> for unsafe fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

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")}> for fn(A, B, C, D, E) -> Ret

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")}> for extern "C" fn(A, B, C, D, E) -> Ret

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")}> for extern "system" fn(A, B, C, D, E) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D, E) -> Ret

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")}> for unsafe fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

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")}> for fn(A, B, C, D, E) -> Ret

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")}> for extern "C" fn(A, B, C, D, E) -> Ret

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")}> for extern "system" fn(A, B, C, D, E) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D, E) -> Ret

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")}> for unsafe fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

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")}> for fn(A, B, C, D, E) -> Ret

Available on 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")}> for extern "C" fn(A, B, C, D, E) -> Ret

Available on 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")}> for extern "system" fn(A, B, C, D, E) -> Ret

Available on 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")}> for extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on 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")}> for unsafe fn(A, B, C, D, E) -> Ret

Available on 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")}> for unsafe extern "C" fn(A, B, C, D, E) -> Ret

Available on 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")}> for unsafe extern "system" fn(A, B, C, D, E) -> Ret

Available on 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")}> for unsafe extern "sysv64" fn(A, B, C, D, E) -> Ret

Available on 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")}> for fn(A, B, C, D, E, F) -> Ret

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")}> for extern "C" fn(A, B, C, D, E, F) -> Ret

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")}> for extern "system" fn(A, B, C, D, E, F) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

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")}> for fn(A, B, C, D, E, F) -> Ret

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")}> for extern "C" fn(A, B, C, D, E, F) -> Ret

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")}> for extern "system" fn(A, B, C, D, E, F) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

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")}> for fn(A, B, C, D, E, F) -> Ret

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")}> for extern "C" fn(A, B, C, D, E, F) -> Ret

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")}> for extern "system" fn(A, B, C, D, E, F) -> Ret

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")}> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

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")}> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

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")}> for fn(A, B, C, D, E, F) -> Ret

Available on 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")}> for extern "C" fn(A, B, C, D, E, F) -> Ret

Available on 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")}> for extern "system" fn(A, B, C, D, E, F) -> Ret

Available on 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")}> for extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on 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")}> for unsafe fn(A, B, C, D, E, F) -> Ret

Available on 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")}> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

Available on 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")}> for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

Available on 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")}> for unsafe extern "sysv64" fn(A, B, C, D, E, F) -> Ret

Available on has_abi_sysv64 only.

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

Implementors