loader

Struct AssertShared

Source 
pub struct AssertShared<T: ?Sized> { /* private fields */ }
Expand description

Asserts that there are no unique pointers to this symbol.

Trait Implementations§

Source§

impl<T: AsPtr + ?Sized> AsPtr for AssertShared<T>

Source§

type Pointer = <T as AsPtr>::Pointer

Source§

unsafe fn as_ptr(&self) -> Self::Pointer

This pointer may point to data which is tied to self’s lifetime. However, this pointer may be a (safe) fn pointer, which is callable without any unsafe. Thus this function is unsafe.
Source§

impl<T: Clone + ?Sized> Clone for AssertShared<T>

Source§

fn clone(&self) -> AssertShared<T>

Returns a copy of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<T: Debug + ?Sized> Debug for AssertShared<T>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl<'a, T: ?Sized> Deref for AssertShared<LibraryVar<'a, T>>

Source§

type Target = T

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl<T: ?Sized> Deref for AssertShared<OwnedLibraryVar<T>>

Source§

type Target = T

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl<'a, R> Fn() for AssertShared<LibraryFunc<'a, extern "C" fn() -> R>>

Source§

extern "rust-call" fn call(&self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, R> Fn() for AssertShared<LibraryFunc<'a, unsafe extern "C" fn() -> R>>

Source§

extern "rust-call" fn call(&self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<R> Fn() for AssertShared<OwnedLibraryFunc<extern "C" fn() -> R>>

Source§

extern "rust-call" fn call(&self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<R> Fn() for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn() -> R>>

Source§

extern "rust-call" fn call(&self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, R> Fn(A) for AssertShared<LibraryFunc<'a, extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call(&self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, R> Fn(A) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call(&self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, R> Fn(A) for AssertShared<OwnedLibraryFunc<extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call(&self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, R> Fn(A) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call(&self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, R> Fn(A, B) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call(&self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, R> Fn(A, B) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call(&self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, R> Fn(A, B) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call(&self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, R> Fn(A, B) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call(&self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, R> Fn(A, B, C) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, R> Fn(A, B, C) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, R> Fn(A, B, C) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, R> Fn(A, B, C) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, R> Fn(A, B, C, D) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, R> Fn(A, B, C, D) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, R> Fn(A, B, C, D) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, R> Fn(A, B, C, D) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, R> Fn(A, B, C, D, E) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, R> Fn(A, B, C, D, E) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, R> Fn(A, B, C, D, E) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, R> Fn(A, B, C, D, E) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, R> Fn(A, B, C, D, E, F) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, R> Fn(A, B, C, D, E, F) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, R> Fn(A, B, C, D, E, F) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, R> Fn(A, B, C, D, E, F) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, R> Fn(A, B, C, D, E, F, G) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, R> Fn(A, B, C, D, E, F, G) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, R> Fn(A, B, C, D, E, F, G) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, R> Fn(A, B, C, D, E, F, G) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, R> Fn(A, B, C, D, E, F, G, H) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, R> Fn(A, B, C, D, E, F, G, H) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, R> Fn(A, B, C, D, E, F, G, H) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, R> Fn(A, B, C, D, E, F, G, H) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, R> Fn(A, B, C, D, E, F, G, H, I) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, R> Fn(A, B, C, D, E, F, G, H, I) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, R> Fn(A, B, C, D, E, F, G, H, I) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, R> Fn(A, B, C, D, E, F, G, H, I) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, J, R> Fn(A, B, C, D, E, F, G, H, I, J) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, J, R> Fn(A, B, C, D, E, F, G, H, I, J) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, J, R> Fn(A, B, C, D, E, F, G, H, I, J) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, J, R> Fn(A, B, C, D, E, F, G, H, I, J) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call( &self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, R> FnMut() for AssertShared<LibraryFunc<'a, extern "C" fn() -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, R> FnMut() for AssertShared<LibraryFunc<'a, unsafe extern "C" fn() -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<R> FnMut() for AssertShared<OwnedLibraryFunc<extern "C" fn() -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<R> FnMut() for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn() -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, R> FnMut(A) for AssertShared<LibraryFunc<'a, extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, R> FnMut(A) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, R> FnMut(A) for AssertShared<OwnedLibraryFunc<extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, R> FnMut(A) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A) -> R>>

Source§

extern "rust-call" fn call_mut(&mut self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, R> FnMut(A, B) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b): (A, B), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, R> FnMut(A, B) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b): (A, B), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, R> FnMut(A, B) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b): (A, B), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, R> FnMut(A, B) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b): (A, B), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, R> FnMut(A, B, C) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, R> FnMut(A, B, C) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, R> FnMut(A, B, C) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, R> FnMut(A, B, C) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, R> FnMut(A, B, C, D) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, R> FnMut(A, B, C, D) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, R> FnMut(A, B, C, D) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, R> FnMut(A, B, C, D) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, R> FnMut(A, B, C, D, E) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, R> FnMut(A, B, C, D, E) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, R> FnMut(A, B, C, D, E) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, R> FnMut(A, B, C, D, E) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, R> FnMut(A, B, C, D, E, F) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, R> FnMut(A, B, C, D, E, F) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, R> FnMut(A, B, C, D, E, F) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, R> FnMut(A, B, C, D, E, F) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, R> FnMut(A, B, C, D, E, F, G) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, R> FnMut(A, B, C, D, E, F, G) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, R> FnMut(A, B, C, D, E, F, G) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, R> FnMut(A, B, C, D, E, F, G) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, R> FnMut(A, B, C, D, E, F, G, H) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, R> FnMut(A, B, C, D, E, F, G, H) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, R> FnMut(A, B, C, D, E, F, G, H) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, R> FnMut(A, B, C, D, E, F, G, H) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, R> FnMut(A, B, C, D, E, F, G, H, I) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, R> FnMut(A, B, C, D, E, F, G, H, I) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, R> FnMut(A, B, C, D, E, F, G, H, I) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, R> FnMut(A, B, C, D, E, F, G, H, I) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, J, R> FnMut(A, B, C, D, E, F, G, H, I, J) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, J, R> FnMut(A, B, C, D, E, F, G, H, I, J) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, J, R> FnMut(A, B, C, D, E, F, G, H, I, J) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, J, R> FnMut(A, B, C, D, E, F, G, H, I, J) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

extern "rust-call" fn call_mut( &mut self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, R> FnOnce() for AssertShared<LibraryFunc<'a, extern "C" fn() -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, R> FnOnce() for AssertShared<LibraryFunc<'a, unsafe extern "C" fn() -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<R> FnOnce() for AssertShared<OwnedLibraryFunc<extern "C" fn() -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<R> FnOnce() for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn() -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (): ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, R> FnOnce(A) for AssertShared<LibraryFunc<'a, extern "C" fn(A) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, R> FnOnce(A) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, R> FnOnce(A) for AssertShared<OwnedLibraryFunc<extern "C" fn(A) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, R> FnOnce(A) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a): (A,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, R> FnOnce(A, B) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, R> FnOnce(A, B) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, R> FnOnce(A, B) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, R> FnOnce(A, B) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once(self, (a, b): (A, B)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, R> FnOnce(A, B, C) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, R> FnOnce(A, B, C) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, R> FnOnce(A, B, C) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, R> FnOnce(A, B, C) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c): (A, B, C), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, R> FnOnce(A, B, C, D) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, R> FnOnce(A, B, C, D) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, R> FnOnce(A, B, C, D) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, R> FnOnce(A, B, C, D) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d): (A, B, C, D), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, R> FnOnce(A, B, C, D, E) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, R> FnOnce(A, B, C, D, E) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, R> FnOnce(A, B, C, D, E) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, R> FnOnce(A, B, C, D, E) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e): (A, B, C, D, E), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, R> FnOnce(A, B, C, D, E, F) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, R> FnOnce(A, B, C, D, E, F) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, R> FnOnce(A, B, C, D, E, F) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, R> FnOnce(A, B, C, D, E, F) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f): (A, B, C, D, E, F), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, R> FnOnce(A, B, C, D, E, F, G) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, R> FnOnce(A, B, C, D, E, F, G) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, R> FnOnce(A, B, C, D, E, F, G) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, R> FnOnce(A, B, C, D, E, F, G) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g): (A, B, C, D, E, F, G), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, R> FnOnce(A, B, C, D, E, F, G, H) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, R> FnOnce(A, B, C, D, E, F, G, H) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, R> FnOnce(A, B, C, D, E, F, G, H) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, R> FnOnce(A, B, C, D, E, F, G, H) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h): (A, B, C, D, E, F, G, H), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, R> FnOnce(A, B, C, D, E, F, G, H, I) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, R> FnOnce(A, B, C, D, E, F, G, H, I) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, R> FnOnce(A, B, C, D, E, F, G, H, I) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, R> FnOnce(A, B, C, D, E, F, G, H, I) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i): (A, B, C, D, E, F, G, H, I), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, J, R> FnOnce(A, B, C, D, E, F, G, H, I, J) for AssertShared<LibraryFunc<'a, extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<'a, A, B, C, D, E, F, G, H, I, J, R> FnOnce(A, B, C, D, E, F, G, H, I, J) for AssertShared<LibraryFunc<'a, unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, J, R> FnOnce(A, B, C, D, E, F, G, H, I, J) for AssertShared<OwnedLibraryFunc<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<A, B, C, D, E, F, G, H, I, J, R> FnOnce(A, B, C, D, E, F, G, H, I, J) for AssertShared<OwnedLibraryFunc<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> R>>

Source§

type Output = R

The returned type after the call operator is used.
Source§

extern "rust-call" fn call_once( self, (a, b, c, d, e, f, g, h, i, j): (A, B, C, D, E, F, G, H, I, J), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)
Performs the call operation.
Source§

impl<T: Leak> Leak for AssertShared<T>

Source§

type Result = AssertShared<<T as Leak>::Result>

Source§

fn leak(self) -> Self::Result

Source§

impl<T: ?Sized, U: ?Sized + CoerceUnsized<T>> CoerceUnsized<AssertShared<T>> for AssertShared<U>

Source§

impl<T: Copy + ?Sized> Copy for AssertShared<T>

Auto Trait Implementations§

§

impl<T> Freeze for AssertShared<T>
where T: Freeze + ?Sized,

§

impl<T> RefUnwindSafe for AssertShared<T>
where T: RefUnwindSafe + ?Sized,

§

impl<T> Send for AssertShared<T>
where T: Send + ?Sized,

§

impl<T> Sync for AssertShared<T>
where T: Sync + ?Sized,

§

impl<T> Unpin for AssertShared<T>
where T: Unpin + ?Sized,

§

impl<T> UnwindSafe for AssertShared<T>
where T: UnwindSafe + ?Sized,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> AssertSendSyncExt for T

Source§

unsafe fn assert_send_sync(self) -> AssertSendSync<Self>

Asserts that this variable/function can be concurrently accessed from different threads, and sent between threads.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<F> Pattern for F
where F: FnMut(char) -> bool,

Source§

type Searcher<'a> = CharPredicateSearcher<'a, F>

🔬This is a nightly-only experimental API. (pattern)
Associated searcher for this pattern
Source§

fn into_searcher<'a>(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>

🔬This is a nightly-only experimental API. (pattern)
Constructs the associated searcher from self and the haystack to search in.
Source§

fn is_contained_in<'a>(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern)
Checks whether the pattern matches anywhere in the haystack
Source§

fn is_prefix_of<'a>(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern)
Checks whether the pattern matches at the front of the haystack
Source§

fn strip_prefix_of<'a>(self, haystack: &'a str) -> Option<&'a str>

🔬This is a nightly-only experimental API. (pattern)
Removes the pattern from the front of haystack, if it matches.
Source§

fn is_suffix_of<'a>(self, haystack: &'a str) -> bool
where CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern)
Checks whether the pattern matches at the back of the haystack
Source§

fn strip_suffix_of<'a>(self, haystack: &'a str) -> Option<&'a str>
where CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern)
Removes the pattern from the back of haystack, if it matches.
Source§

fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>>

🔬This is a nightly-only experimental API. (pattern)
Returns the pattern as utf-8 bytes if possible.
Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.