Trait WithSafety 

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

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

Required Associated Types

type F: FnPtr + HasSafety<SAFE>

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

Implementations on Foreign Types

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

type F = unsafe fn() -> Ret

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

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

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

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

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

type F = unsafe fn() -> Ret

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

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

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

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

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

type F = fn() -> Ret

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

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

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

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

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

type F = fn() -> Ret

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

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

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

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

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

type F = unsafe fn(A) -> Ret

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

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

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

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

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

type F = unsafe fn(A) -> Ret

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

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

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

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

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

type F = fn(A) -> Ret

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

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

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

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

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

type F = fn(A) -> Ret

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

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

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

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

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

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

impl<Ret: 'static, A: 'static, B: 'static> WithSafety<false> 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> 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> for unsafe fn(A, B) -> Ret

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

impl<Ret: 'static, A: 'static, B: 'static> WithSafety<false> 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> 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<true> for fn(A, B) -> Ret

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

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

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

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

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

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

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

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

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> WithSafety<false> 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> 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> 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> 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> 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> 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<true> for fn(A, B, C) -> Ret

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

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

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

Implementors