Trait FnPtr 

pub trait FnPtr:
    PartialEq
    + Eq
    + PartialOrd
    + Ord
    + Hash
    + Pointer
    + Debug
    + Clone
    + Copy
    + Send
    + Sync
    + Unpin
    + UnwindSafe
    + RefUnwindSafe
    + 'static {
    type Args;
    type Output;

    const ARITY: usize;
    const IS_SAFE: bool;
    const IS_EXTERN: bool;
    const ABI: 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors