Trait FnPtr 

pub trait FnPtr:
    PartialEq
    + Eq
    + PartialOrd
    + Ord
    + Hash
    + Pointer
    + Debug
    + Clone
    + Copy
    + Send
    + Sync
    + Unpin
    + UnwindSafe
    + RefUnwindSafe
    + Sized
    + 'static
    + WithSafety<true>
    + WithSafety<false>
    + WithAbi<{ _ }>
    + WithAbi<{ _ }>
    + WithAbi<{ _ }> {
    type Args;
    type Output;

    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<{ false }>>::F { ... }
    unsafe fn as_safe(&self) -> <Self as WithSafety<{ true }>>::F { ... }
    unsafe fn with_abi<const ABI: u8>(&self) -> <Self as WithAbi<ABI>>::F
       where Self: WithAbi<ABI> { ... }
}

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.

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

This function is unsafe because it can not check if the argument points 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

This function is unsafe because it can not check if the argument points to a function of the correct type.

fn as_unsafe(&self) -> <Self as WithSafety<{ false }>>::F

Produces an unsafe version of this function pointer.

unsafe fn as_safe(&self) -> <Self as WithSafety<{ true }>>::F

Produces a safe version of this function pointer.

Safety

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

unsafe fn with_abi<const ABI: u8>(&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.

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: 'static> FnPtr for fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 0usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

impl<Ret: 'static> FnPtr for unsafe fn() -> Ret

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 0usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = ()

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 1usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = (A,)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 2usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = (A, B)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 3usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

type Args = (A, B, C)

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 4usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 5usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = true

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = false

const ABI: Abi = crate::Abi::Rust

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::C

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::System

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

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

const ARITY: usize = 6usize

const IS_SAFE: bool = false

const IS_EXTERN: bool = true

const ABI: Abi = crate::Abi::Sysv64

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

type Output = Ret

fn as_ptr(&self) -> UntypedFnPtr

unsafe fn from_ptr(ptr: UntypedFnPtr) -> Self

Implementors