Trait FunctionPtr 

pub unsafe trait FunctionPtr:
    Sized
    + Copy
    + Debug
    + Send
    + Sync
    + 'static {
    type Args;
    type Output;

    const ARITY: usize;
    const SAFE: bool;
    const EXTERN: bool;
    const ABI: Abi;
}

Trait representing a function.

Safety

This trait should only be implemented for function pointers and the associated types and constants have to match the function pointer type.

Required Associated Constants

const ARITY: usize

The function’s arity (number of arguments).

const SAFE: bool

Whether this function is safe to call.

const EXTERN: bool

Whether this function is extern.

const ABI: Abi

The ABI of this function.

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> FunctionPtr for fn() -> Ret

const ARITY: usize = 0usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

type Args = ()

type Output = Ret

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

const ARITY: usize = 0usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = ()

type Output = Ret

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

const ARITY: usize = 0usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = ()

type Output = Ret

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

const ARITY: usize = 0usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

type Args = ()

type Output = Ret

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

const ARITY: usize = 0usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = ()

type Output = Ret

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

const ARITY: usize = 0usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = ()

type Output = Ret

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

const ARITY: usize = 1usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

type Args = (A,)

type Output = Ret

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

const ARITY: usize = 1usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A,)

type Output = Ret

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

const ARITY: usize = 1usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A,)

type Output = Ret

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

const ARITY: usize = 1usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

type Args = (A,)

type Output = Ret

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

const ARITY: usize = 1usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A,)

type Output = Ret

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

const ARITY: usize = 1usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A,)

type Output = Ret

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

const ARITY: usize = 2usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B)

type Output = Ret

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

const ARITY: usize = 2usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B)

type Output = Ret

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

const ARITY: usize = 2usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B)

type Output = Ret

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

const ARITY: usize = 2usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B)

type Output = Ret

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

const ARITY: usize = 2usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B)

type Output = Ret

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

const ARITY: usize = 2usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B)

type Output = Ret

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

const ARITY: usize = 3usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C)

type Output = Ret

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

const ARITY: usize = 3usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C)

type Output = Ret

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

const ARITY: usize = 3usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C)

type Output = Ret

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

const ARITY: usize = 3usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C)

type Output = Ret

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

const ARITY: usize = 3usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C)

type Output = Ret

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

const ARITY: usize = 3usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C)

type Output = Ret

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

const ARITY: usize = 4usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 4usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 4usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 4usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 4usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 4usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 5usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 5usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 5usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 5usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 5usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 5usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

const ARITY: usize = 6usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

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

const ARITY: usize = 6usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

const ARITY: usize = 6usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

const ARITY: usize = 6usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

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

const ARITY: usize = 6usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

const ARITY: usize = 6usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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, G: 'static> FunctionPtr for fn(A, B, C, D, E, F, G) -> Ret

const ARITY: usize = 7usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 7usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 7usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 7usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 7usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 7usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 8usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 8usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 8usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 8usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 8usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 8usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> FunctionPtr for fn(A, B, C, D, E, F, G, H, I) -> Ret

const ARITY: usize = 9usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 9usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 9usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 9usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 9usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

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

const ARITY: usize = 9usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

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

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> FunctionPtr for fn(A, B, C, D, E, F, G, H, I, J) -> Ret

const ARITY: usize = 10usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> FunctionPtr for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

const ARITY: usize = 10usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> FunctionPtr for extern "system" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

const ARITY: usize = 10usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> FunctionPtr for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret

const ARITY: usize = 10usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> FunctionPtr for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

const ARITY: usize = 10usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> FunctionPtr for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

const ARITY: usize = 10usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> FunctionPtr for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize = 11usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> FunctionPtr for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize = 11usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> FunctionPtr for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize = 11usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> FunctionPtr for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize = 11usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> FunctionPtr for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize = 11usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> FunctionPtr for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize = 11usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> FunctionPtr for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize = 12usize

const SAFE: bool = true

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> FunctionPtr for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize = 12usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> FunctionPtr for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize = 12usize

const SAFE: bool = true

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> FunctionPtr for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize = 12usize

const SAFE: bool = false

const EXTERN: bool = false

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> FunctionPtr for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize = 12usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> FunctionPtr for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize = 12usize

const SAFE: bool = false

const EXTERN: bool = true

const ABI: Abi

type Args = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

Implementors