W3cubDocs

/Rust

Primitive Type fn

Function pointers, like fn(usize) -> bool.

See also the traits Fn, FnMut, and FnOnce.

Function pointers are pointers that point to code, not data. They can be called just like functions. Like references, function pointers are, among other things, assumed to not be null, so if you want to pass a function pointer over FFI and be able to accommodate null pointers, make your type Option<fn()> with your required signature.

Safety

Plain function pointers are obtained by casting either plain functions, or closures that don't capture an environment:

fn add_one(x: usize) -> usize {
    x + 1
}

let ptr: fn(usize) -> usize = add_one;
assert_eq!(ptr(5), 6);

let clos: fn(usize) -> usize = |x| x + 5;
assert_eq!(clos(5), 10);

In addition to varying based on their signature, function pointers come in two flavors: safe and unsafe. Plain fn() function pointers can only point to safe functions, while unsafe fn() function pointers can point to safe or unsafe functions.

fn add_one(x: usize) -> usize {
    x + 1
}

unsafe fn add_one_unsafely(x: usize) -> usize {
    x + 1
}

let safe_ptr: fn(usize) -> usize = add_one;

//ERROR: mismatched types: expected normal fn, found unsafe fn
//let bad_ptr: fn(usize) -> usize = add_one_unsafely;

let unsafe_ptr: unsafe fn(usize) -> usize = add_one_unsafely;
let really_safe_ptr: unsafe fn(usize) -> usize = add_one;

ABI

On top of that, function pointers can vary based on what ABI they use. This is achieved by adding the extern keyword before the type, followed by the ABI in question. The default ABI is "Rust", i.e., fn() is the exact same type as extern "Rust" fn(). A pointer to a function with C ABI would have type extern "C" fn().

extern "ABI" { ... } blocks declare functions with ABI "ABI". The default here is "C", i.e., functions declared in an extern {...} block have "C" ABI.

For more information and a list of supported ABIs, see [the nomicon's section on foreign calling conventions][nomicon-abi].

Variadic functions

Extern function declarations with the "C" or "cdecl" ABIs can also be variadic, allowing them to be called with a variable number of arguments. Normal Rust functions, even those with an extern "ABI", cannot be variadic. For more information, see the nomicon's section on variadic functions.

Creating function pointers

When bar is the name of a function, then the expression bar is not a function pointer. Rather, it denotes a value of an unnameable type that uniquely identifies the function bar. The value is zero-sized because the type already identifies the function. This has the advantage that "calling" the value (it implements the Fn* traits) does not require dynamic dispatch.

This zero-sized type coerces to a regular function pointer. For example:

use std::mem;

fn bar(x: i32) {}

let not_bar_ptr = bar; // `not_bar_ptr` is zero-sized, uniquely identifying `bar`
assert_eq!(mem::size_of_val(&not_bar_ptr), 0);

let bar_ptr: fn(i32) = not_bar_ptr; // force coercion to function pointer
assert_eq!(mem::size_of_val(&bar_ptr), mem::size_of::<usize>());

let footgun = &bar; // this is a shared reference to the zero-sized type identifying `bar`

The last line shows that &bar is not a function pointer either. Rather, it is a reference to the function-specific ZST. &bar is basically never what you want when bar is a function.

Traits

Function pointers implement the following traits:

Due to a temporary restriction in Rust's type system, these traits are only implemented on functions that take 12 arguments or less, with the "Rust" and "C" ABIs. In the future, this may change.

In addition, function pointers of any signature, ABI, or safety are Copy, and all safe function pointers implement Fn, FnMut, and FnOnce. This works because these traits are specially known to the compiler.

Trait Implementations

`impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for extern "C" fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Debug for fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Debug for fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for unsafe fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Debug for unsafe fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Debug for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for unsafe fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Debug for unsafe fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Debug for unsafe extern "C" fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Debug for unsafe extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Debug for extern "C" fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for unsafe extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`impl<Ret, A, B> Eq for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H> Eq for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F> Eq for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H> Eq for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H> Eq for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`impl<Ret, A, B, C> Eq for fn(A, B, C) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Eq for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F> Eq for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D> Eq for fn(A, B, C, D) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D> Eq for unsafe extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`impl<Ret, A> Eq for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D> Eq for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G> Eq for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`impl<Ret, A> Eq for unsafe fn(A) -> Ret`[src]1.4.0

`impl<Ret, A, B> Eq for unsafe extern "C" fn(A, B) -> Ret`[src]1.4.0

`impl<Ret> Eq for extern "C" fn() -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`impl<Ret, A> Eq for fn(A) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E> Eq for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H> Eq for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D> Eq for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G> Eq for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C> Eq for unsafe extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`impl<Ret, A> Eq for extern "C" fn(A) -> Ret`[src]1.4.0

`impl<Ret, A> Eq for extern "C" fn(A, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E> Eq for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`impl<Ret, A, B, C> Eq for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E> Eq for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`impl<Ret> Eq for unsafe extern "C" fn() -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F> Eq for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F> Eq for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`impl<Ret, A, B, C> Eq for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G> Eq for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E> Eq for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`impl<Ret, A> Eq for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B> Eq for extern "C" fn(A, B) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E> Eq for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D> Eq for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`impl<Ret, A, B> Eq for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C> Eq for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`impl<Ret> Eq for unsafe fn() -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F> Eq for fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B> Eq for fn(A, B) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C> Eq for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G> Eq for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F> Eq for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B> Eq for unsafe fn(A, B) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D> Eq for unsafe fn(A, B, C, D) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E> Eq for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`impl<Ret> Eq for fn() -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Eq for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A> Hash for extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C> Hash for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B> Hash for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C> Hash for fn(A, B, C) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A> Hash for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H> Hash for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E> Hash for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B> Hash for unsafe fn(A, B) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Hash for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G> Hash for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F> Hash for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D> Hash for unsafe fn(A, B, C, D) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E> Hash for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret> Hash for extern "C" fn() -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F> Hash for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B> Hash for fn(A, B) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H> Hash for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Hash for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D> Hash for fn(A, B, C, D) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B> Hash for extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A> Hash for unsafe fn(A) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G> Hash for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A> Hash for extern "C" fn(A) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A> Hash for fn(A) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret> Hash for fn() -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H> Hash for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A> Hash for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Hash for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F> Hash for fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret> Hash for unsafe fn() -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Hash for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F, G> Hash for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret> Hash for unsafe extern "C" fn() -> Ret`[src]1.4.0

`fn hash<HH>(&self, state: &mut HH) where HH: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E> Ord for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A> Ord for fn(A) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A> Ord for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A> Ord for extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C> Ord for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D> Ord for unsafe fn(A, B, C, D) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C> Ord for fn(A, B, C) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A> Ord for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A> Ord for unsafe fn(A) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret> Ord for extern "C" fn() -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn() -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B> Ord for extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E> Ord for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Ord for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G> Ord for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B> Ord for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A> Ord for extern "C" fn(A) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret> Ord for unsafe fn() -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe fn() -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D> Ord for fn(A, B, C, D) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret> Ord for unsafe extern "C" fn() -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B> Ord for fn(A, B) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret> Ord for fn() -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn() -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn cmp(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn cmp(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn() -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B, C) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`[src]1.4.0

`fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret`[src]1.4.0

`fn eq(&self, other: &fn() -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialEq<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialEq<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D, E) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A, B) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret`[src]1.4.0

`fn eq(&self, other: &fn(A) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn() -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn() -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn eq( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialEq<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialEq<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B, C) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A, B) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`[src]1.4.0

`fn eq(&self, other: &unsafe fn(A) -> Ret) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &extern "C" fn() -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &extern "C" fn(A) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &fn() -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialOrd<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialOrd<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &fn(A, B, C) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E> PartialOrd<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E) -> Ret ) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`[src]1.4.0

`fn partial_cmp(&self, other: &unsafe fn(A) -> Ret) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Pointer for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Pointer for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Pointer for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Pointer for fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Pointer for fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Pointer for fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Pointer for unsafe fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Pointer for extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Pointer for fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Pointer for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Pointer for unsafe fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Pointer for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Pointer for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Pointer for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Pointer for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Pointer for extern "C" fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Pointer for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Pointer for fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Pointer for unsafe extern "C" fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Pointer for unsafe fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Pointer for unsafe extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Pointer for fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Pointer for unsafe fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Pointer for extern "C" fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Pointer for unsafe extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Pointer for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Pointer for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Pointer for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Pointer for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Pointer for extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/primitive.fn.html

Primitive Type fn

Safety

ABI

Variadic functions

Creating function pointers

Traits

Trait Implementations

impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[src]1.4.0

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

impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F> Debug for unsafe fn(A, B, C, D, E, F) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E) -> Ret[src]1.4.0

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

impl<Ret, A> Debug for extern "C" fn(A) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D> Debug for fn(A, B, C, D) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret[src]1.4.0

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

impl<Ret, A> Debug for fn(A) -> Ret[src]1.4.0

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

impl<Ret, A, B> Debug for fn(A, B) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E> Debug for fn(A, B, C, D, E) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src]1.4.0

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

impl<Ret, A, B, C> Debug for unsafe fn(A, B, C) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G, H> Debug for fn(A, B, C, D, E, F, G, H) -> Ret[src]1.4.0

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

impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B, ...) -> Ret[src]1.4.0

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

impl<Ret> Debug for fn() -> Ret[src]1.4.0

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

impl<Ret, A> Debug for unsafe extern "C" fn(A) -> Ret[src]1.4.0

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

impl<Ret, A> Debug for unsafe extern "C" fn(A, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B> Debug for unsafe fn(A, B) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F) -> Ret[src]1.4.0

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

impl<Ret> Debug for unsafe fn() -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F, G> Debug for fn(A, B, C, D, E, F, G) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F, ...) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret[src]1.4.0

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

impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C) -> Ret[src]1.4.0

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

impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D, ...) -> Ret[src]1.4.0

`impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for unsafe fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for extern "C" fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Debug for fn(A, B, C, D) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for unsafe fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G, H> Debug for fn(A, B, C, D, E, F, G, H) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Debug for fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for unsafe extern "C" fn(A) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A> Debug for unsafe extern "C" fn(A, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for unsafe fn(A, B) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret> Debug for unsafe fn() -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for extern "C" fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F> Debug for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E, F, G> Debug for unsafe fn(A, B, C, D, E, F, G) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B, C, D, E> Debug for unsafe fn(A, B, C, D, E) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<Ret, A, B> Debug for extern "C" fn(A, B, ...) -> Ret`[src]1.4.0

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]