Trait WithSafety 

pub trait WithSafety<const SAFE: bool, F: FnPtr> {
    type F: FnPtr;
}

Computes the function pointer type obtained by switching between safe/unsafe while preserving arity, ABI, and signature.

Required Associated Types

type F: FnPtr

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

Implementations on Foreign Types

impl<Ret: 'static> WithSafety<false, fn() -> Ret> for fn() -> Ret

type F = unsafe fn() -> Ret

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

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

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

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

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

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

impl<Ret: 'static> WithSafety<false, unsafe fn() -> Ret> for unsafe fn() -> Ret

type F = unsafe fn() -> Ret

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

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

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

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

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

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

impl<Ret: 'static> WithSafety<true, fn() -> Ret> for fn() -> Ret

type F = fn() -> Ret

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

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

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

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

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

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

impl<Ret: 'static> WithSafety<true, unsafe fn() -> Ret> for unsafe fn() -> Ret

type F = fn() -> Ret

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

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

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

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

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

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

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

type F = unsafe fn(A) -> Ret

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

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

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

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

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

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

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

type F = unsafe fn(A) -> Ret

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

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

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

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

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

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

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

type F = fn(A) -> Ret

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

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

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

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

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

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

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

type F = fn(A) -> Ret

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors