Trait FnPtr 

pub trait FnPtr:
    PartialEq
    + Eq
    + PartialOrd
    + Ord
    + Hash
    + Pointer
    + Debug
    + Clone
    + Copy
    + Send
    + Sync
    + Unpin
    + UnwindSafe
    + RefUnwindSafe
    + Sized {
    type Args;
    type Output;
    type ArityMarker: Arity;
    type SafetyMarker: Safety;
    type AbiMarker: Abi;

    const ARITY: usize;
    const IS_SAFE: bool;
    const IS_EXTERN: bool;
    const ABI: Abi;

    // Required methods
    fn as_ptr(&self) -> UntypedFnPtr;
    unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self;

    // Provided methods
    fn addr(&self) -> usize { ... }
    unsafe fn from_addr(addr: usize) -> Self { ... }
    fn as_unsafe(&self) -> <Self as WithSafety<Unsafe>>::F
       where Self: AsUnsafe { ... }
    unsafe fn as_safe(&self) -> <Self as WithSafety<Safe>>::F
       where Self: AsSafe { ... }
    unsafe fn with_abi<Abi: Abi>(&self) -> <Self as WithAbi<Abi>>::F
       where Self: WithAbi<Abi> { ... }
    unsafe fn with_safety<Safety: Safety>(
        &self,
    ) -> <Self as WithSafety<Safety>>::F
       where Self: WithSafety<Safety> { ... }
}

Marker trait for all function pointers.

Required Associated Constants

const ARITY: usize

The function’s arity (number of arguments).

const IS_SAFE: bool

Whether the function pointer is safe (fn) or unsafe (unsafe fn).

const IS_EXTERN: bool

Whether the function pointer uses an extern calling convention.

const ABI: Abi

The ABI associated with this function pointer.

Required Associated Types

type Args

The argument types as a tuple.

type Output

The return type.

type ArityMarker: Arity

Marker type denoting arity

type SafetyMarker: Safety

Marker type denoting safety

type AbiMarker: Abi

Marker type denoting abi

Required Methods

fn as_ptr(&self) -> UntypedFnPtr

Returns a untyped function pointer for this function.

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

Constructs an instance from an untyped function pointer.

Safety

The given pointer has to point to a function of the correct type.

Provided Methods

fn addr(&self) -> usize

Returns the address of this function.

unsafe fn from_addr(addr: usize) -> Self

Constructs an instance from an address.

Safety

The given pointer has to point to a function of the correct type.

fn as_unsafe(&self) -> <Self as WithSafety<Unsafe>>::F

where Self: AsUnsafe,

Produces an unsafe version of this function pointer.

unsafe fn as_safe(&self) -> <Self as WithSafety<Safe>>::F

where Self: AsSafe,

Produces a safe version of this function pointer.

Safety

Caller must ensure the underlying function is actually safe to call.

unsafe fn with_abi<Abi: Abi>(&self) -> <Self as WithAbi<Abi>>::F

where Self: WithAbi<Abi>,

Produces a version of this function pointer with the given ABI.

Safety

Caller must ensure that the resulting ABI transformation is sound.

unsafe fn with_safety<Safety: Safety>(&self) -> <Self as WithSafety<Safety>>::F

where Self: WithSafety<Safety>,

Produces a version of this function pointer with the given safety.

Safety

Caller must ensure that this function pointer is safe when casting to a safe function.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<Ret> FnPtr for fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Safe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for extern "C" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Safe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for extern "C-unwind" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Safe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for extern "system" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Safe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for extern "system-unwind" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Safe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for extern "sysv64" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Safe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for extern "sysv64-unwind" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Safe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for unsafe fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Unsafe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for unsafe extern "C" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Unsafe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for unsafe extern "C-unwind" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Unsafe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for unsafe extern "system" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Unsafe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for unsafe extern "system-unwind" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Unsafe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for unsafe extern "sysv64" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Unsafe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret> FnPtr for unsafe extern "sysv64-unwind" fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = ()

type Output = Ret

type ArityMarker = A0

type SafetyMarker = Unsafe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Safe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for extern "C" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Safe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for extern "C-unwind" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Safe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for extern "system" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Safe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for extern "system-unwind" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Safe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for extern "sysv64" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Safe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for extern "sysv64-unwind" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Safe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for unsafe fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Unsafe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for unsafe extern "C" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Unsafe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for unsafe extern "C-unwind" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Unsafe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for unsafe extern "system" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Unsafe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for unsafe extern "system-unwind" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Unsafe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for unsafe extern "sysv64" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Unsafe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A> FnPtr for unsafe extern "sysv64-unwind" fn(A) -> Ret

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A,)

type Output = Ret

type ArityMarker = A1

type SafetyMarker = Unsafe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Safe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for extern "C" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Safe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for extern "C-unwind" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Safe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for extern "system" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Safe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for extern "system-unwind" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Safe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for extern "sysv64" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Safe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for extern "sysv64-unwind" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Safe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for unsafe fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Unsafe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for unsafe extern "C" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Unsafe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Unsafe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for unsafe extern "system" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Unsafe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Unsafe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B> FnPtr for unsafe extern "sysv64" fn(A, B) -> Ret

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Unsafe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B)

type Output = Ret

type ArityMarker = A2

type SafetyMarker = Unsafe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C> FnPtr for fn(A, B, C) -> Ret

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Safe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C> FnPtr for extern "C" fn(A, B, C) -> Ret

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Safe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C> FnPtr for extern "C-unwind" fn(A, B, C) -> Ret

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Safe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C> FnPtr for extern "system" fn(A, B, C) -> Ret

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Safe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Safe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C> FnPtr for extern "sysv64" fn(A, B, C) -> Ret

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Safe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Safe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C> FnPtr for unsafe fn(A, B, C) -> Ret

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Unsafe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C> FnPtr for unsafe extern "C" fn(A, B, C) -> Ret

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Unsafe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Unsafe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Unsafe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Unsafe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Unsafe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C)

type Output = Ret

type ArityMarker = A3

type SafetyMarker = Unsafe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C, D> FnPtr for fn(A, B, C, D) -> Ret

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Safe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C, D> FnPtr for extern "C" fn(A, B, C, D) -> Ret

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Safe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Safe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Safe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Safe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Safe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Safe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C, D> FnPtr for unsafe fn(A, B, C, D) -> Ret

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Unsafe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Unsafe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Unsafe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Unsafe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Unsafe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Unsafe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D)

type Output = Ret

type ArityMarker = A4

type SafetyMarker = Unsafe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C, D, E> FnPtr for fn(A, B, C, D, E) -> Ret

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Safe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Safe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Safe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Safe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Safe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Safe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Safe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C, D, E> FnPtr for unsafe fn(A, B, C, D, E) -> Ret

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Unsafe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Unsafe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Unsafe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Unsafe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Unsafe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Unsafe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E)

type Output = Ret

type ArityMarker = A5

type SafetyMarker = Unsafe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret, A, B, C, D, E, F> FnPtr for fn(A, B, C, D, E, F) -> Ret

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Safe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Safe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Safe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Safe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Safe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Safe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Safe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::Rust as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = false

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Unsafe

type AbiMarker = Rust

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::C as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Unsafe

type AbiMarker = C

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::CUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Unsafe

type AbiMarker = CUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::System as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Unsafe

type AbiMarker = System

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SystemUnwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Unsafe

type AbiMarker = SystemUnwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64 as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Unsafe

type AbiMarker = SysV64

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const ABI: Abi = <crate::marker::SysV64Unwind as crate::marker::Abi>::VALUE

const IS_EXTERN: bool = true

type Args = (A, B, C, D, E, F)

type Output = Ret

type ArityMarker = A6

type SafetyMarker = Unsafe

type AbiMarker = SysV64Unwind

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

Implementors