fn - Rust
Description: API documentation for the Rust `fn` primitive in crate `std`.
Keywords: rust, rustlang, rust-lang, fn

# 1.0.0[−]Primitive Type fn

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

See also the traits `Fn`, `FnMut`, and `FnOnce`.

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);Run

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;Run

On top of that, function pointers can vary based on what ABI they use. This is achieved by adding the `extern` keyword to the type name, followed by the ABI in question. For example, `fn()` is different from `extern "C" fn()`, which itself is different from `extern "stdcall" fn()`, and so on for the various ABIs that Rust supports. Non-`extern` functions have an ABI of `"Rust"`, and `extern` functions without an explicit ABI have an ABI of `"C"`. For more information, see the nomicon's section on foreign calling conventions.

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.

These markers can be combined, so `unsafe extern "stdcall" fn()` is a valid type.

Like references in rust, function pointers are 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.

Function pointers implement the following traits:

- `Clone`
- `PartialEq`
- `Eq`
- `PartialOrd`
- `Ord`
- `Hash`
- `Pointer`
- `Debug`

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for fn(A, B, C, D, E, F, G, H, I) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B> Pointer for extern "C" fn(A, B, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E> Pointer for unsafe extern "C" fn(A, B, C, D, E) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G> Pointer for fn(A, B, C, D, E, F, G) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F> Pointer for fn(A, B, C, D, E, F) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B> Pointer for fn(A, B) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F> Pointer for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E> Pointer for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe fn(A, B, C, D, E, F, G, H) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A> Pointer for extern "C" fn(A, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E> Pointer for extern "C" fn(A, B, C, D, E) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A> Pointer for fn(A) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G, H> Pointer for fn(A, B, C, D, E, F, G, H) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C> Pointer for unsafe extern "C" fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C> Pointer for unsafe extern "C" fn(A, B, C, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D> Pointer for fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret> Pointer for unsafe fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C> Pointer for unsafe fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe fn(A, B, C, D, E, F, G) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A> Pointer for unsafe extern "C" fn(A) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret> Pointer for fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret> Pointer for unsafe extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D> Pointer for unsafe fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A> Pointer for unsafe fn(A) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret> Pointer for extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E> Pointer for extern "C" fn(A, B, C, D, E, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A> Pointer for extern "C" fn(A) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B> Pointer for extern "C" fn(A, B) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A> Pointer for unsafe extern "C" fn(A, ...) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E, F> Pointer for unsafe fn(A, B, C, D, E, F) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B> Pointer for unsafe fn(A, B) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E> Pointer for fn(A, B, C, D, E) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C, D, E> Pointer for unsafe fn(A, B, C, D, E) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`impl<Ret, A, B, C> Pointer for fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter.

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret> Hash for fn() -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret, A, B> Hash for unsafe fn(A, B) -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret, A, B, C> Hash for fn(A, B, C) -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret, A, B> Hash for fn(A, B) -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret> Hash for unsafe fn() -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret, A> Hash for unsafe fn(A) -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret> Hash for unsafe extern "C" fn() -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret> Hash for extern "C" fn() -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`impl<Ret, A> Hash for fn(A) -> Ret`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

`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`

1.4.0
[src]

####

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

[src]

Feeds this value into the given [`Hasher`]. Read more

####

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

1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`impl<Ret, A, B> Eq for fn(A, B) -> Ret`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`impl<Ret, A, B, C> Eq for fn(A, B, C) -> Ret`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`impl<Ret> Eq for unsafe extern "C" fn() -> Ret`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`impl<Ret> Eq for extern "C" fn() -> Ret`

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`impl<Ret, A> Eq for fn(A) -> Ret`

1.4.0
[src]

###

`impl<Ret> Eq for unsafe fn() -> Ret`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[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`

1.4.0
[src]

###

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

1.4.0
[src]

###

`impl<Ret, A, B> Eq for unsafe fn(A, B) -> Ret`

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`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`

1.4.0
[src]

###

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

1.4.0
[src]

###

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

1.4.0
[src]

###

`impl<Ret> Eq for fn() -> Ret`

1.4.0
[src]

###

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

1.4.0
[src]

###

`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`

1.4.0
[src]

###

`impl<Ret, A> Eq for unsafe fn(A) -> Ret`

1.4.0
[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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret> Debug for fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret, A, B, C> Debug for fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret, A> Debug for fn(A) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret, A> Debug for unsafe fn(A) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret> Debug for extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret> Debug for unsafe extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret, A, B> Debug for unsafe fn(A, B) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret> Debug for unsafe fn() -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret, A, B> Debug for fn(A, B) -> Ret`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`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`

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

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

1.4.0
[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

[src]

Formats the value using the given formatter. Read more

###

`impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

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

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn() -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn() -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn() -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe fn(A, B) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &fn() -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`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`

1.4.0
[src]

####

`fn eq( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

`impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`

1.4.0
[src]

####

`fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool`

[src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

####

`#[must_use] fn ne(&self, other: &Rhs) -> bool`

[src]

This method tests for `!=`.

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A, B, C> Ord for fn(A, B, C) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret> Ord for fn() -> Ret`

1.4.0
[src]

####

`fn cmp(&self, other: &fn() -> Ret) -> Ordering`

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A> Ord for unsafe fn(A) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret> Ord for unsafe fn() -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A, B> Ord for fn(A, B) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A> Ord for fn(A) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret> Ord for unsafe extern "C" fn() -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret> Ord for extern "C" fn() -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

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

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an `Ordering` between `self` and `other`. Read more

####

`fn max(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the maximum of two values. Read more

####

`fn min(self, other: Self) -> Self`

1.21.0
[src]

Compares and returns the minimum of two values. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &unsafe fn(A) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &fn(A, B, C) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &fn() -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`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]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`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]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &extern "C" fn() -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret`

1.4.0
[src]

####

`fn partial_cmp(&self, other: &extern "C" fn(A) -> Ret) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

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

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &extern "C" fn(A, B, C, D, E) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, ...) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

###

`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`

1.4.0
[src]

####

`fn partial_cmp( &self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret ) -> Option<Ordering>`

[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

####

`#[must_use] fn lt(&self, other: &Rhs) -> bool`

[src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

####

`#[must_use] fn le(&self, other: &Rhs) -> bool`

[src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

####

`#[must_use] fn gt(&self, other: &Rhs) -> bool`

[src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

####

`#[must_use] fn ge(&self, other: &Rhs) -> bool`

[src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)