Primitive Type fn1.0.0[−]
Function pointers, like fn(usize) -> bool
.
See also the traits Fn
, FnMut
, and FnOnce
.
Function pointers are pointers that point to code, not data. They can be called
just like functions. Like references, function pointers are, among other things, assumed to
not be null, so if you want to pass a function pointer over FFI and be able to accommodate null
pointers, make your type Option<fn()>
with your required signature.
Safety
Plain function pointers are obtained by casting either plain functions, or closures that don’t capture an environment:
fn add_one(x: usize) -> usize { x + 1 } let ptr: fn(usize) -> usize = add_one; assert_eq!(ptr(5), 6); let clos: fn(usize) -> usize = |x| x + 5; assert_eq!(clos(5), 10);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
ABI
On top of that, function pointers can vary based on what ABI they use. This
is achieved by adding the extern
keyword before the type, followed by the
ABI in question. The default ABI is “Rust”, i.e., fn()
is the exact same
type as extern "Rust" fn()
. A pointer to a function with C ABI would have
type extern "C" fn()
.
extern "ABI" { ... }
blocks declare functions with ABI “ABI”. The default
here is “C”, i.e., functions declared in an extern {...}
block have “C”
ABI.
For more information and a list of supported ABIs, see the nomicon’s section on foreign calling conventions.
Variadic functions
Extern function declarations with the “C” or “cdecl” ABIs can also be variadic, allowing them
to be called with a variable number of arguments. Normal Rust functions, even those with an
extern "ABI"
, cannot be variadic. For more information, see the nomicon’s section on
variadic functions.
Creating function pointers
When bar
is the name of a function, then the expression bar
is not a
function pointer. Rather, it denotes a value of an unnameable type that
uniquely identifies the function bar
. The value is zero-sized because the
type already identifies the function. This has the advantage that “calling”
the value (it implements the Fn*
traits) does not require dynamic
dispatch.
This zero-sized type coerces to a regular function pointer. For example:
use std::mem; fn bar(x: i32) {} let not_bar_ptr = bar; // `not_bar_ptr` is zero-sized, uniquely identifying `bar` assert_eq!(mem::size_of_val(¬_bar_ptr), 0); let bar_ptr: fn(i32) = not_bar_ptr; // force coercion to function pointer assert_eq!(mem::size_of_val(&bar_ptr), mem::size_of::<usize>()); let footgun = &bar; // this is a shared reference to the zero-sized type identifying `bar`Run
The last line shows that &bar
is not a function pointer either. Rather, it
is a reference to the function-specific ZST. &bar
is basically never what you
want when bar
is a function.
Traits
Function pointers implement the following traits:
Due to a temporary restriction in Rust’s type system, these traits are only implemented on
functions that take 12 arguments or less, with the "Rust"
and "C"
ABIs. In the future, this
may change.
In addition, function pointers of any signature, ABI, or safety are Copy
, and all safe
function pointers implement Fn
, FnMut
, and FnOnce
. This works because these traits
are specially known to the compiler.
Trait Implementations
impl<Ret, A, B, C, D, 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]
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]
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]
impl<Ret, A, B, C, D, E> Debug for fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Debug 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, K, L> Debug 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> Debug for extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Debug for fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
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]
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]
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]
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]
impl<Ret, A> Debug for extern "C" fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Debug for fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Debug for fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Debug for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret, A> Debug for extern "C" fn(A, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
impl<Ret> Debug for fn() -> Ret
1.4.0[src]
impl<Ret, A, B> Debug for unsafe fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Debug for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
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]
impl<Ret, A, B, C> Debug for unsafe extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
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]
impl<Ret, A> Debug for unsafe extern "C" fn(A, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
1.4.0[src]
impl<Ret> Debug for extern "C" fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Debug for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
impl<Ret, A, B> Debug for extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
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]
impl<Ret, A, B, C, D> Debug for extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Debug for extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Debug for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Debug 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> Debug 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> Debug for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret, A, B> Debug for extern "C" fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A> Debug for 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]
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]
impl<Ret, A, B, C, D, E> Debug for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret> Debug for unsafe extern "C" fn() -> Ret
1.4.0[src]
impl<Ret, A, B> Debug for fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Debug for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Debug for unsafe extern "C" fn(A, B, C) -> 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]
impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret> Debug for unsafe fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Debug for unsafe fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Debug for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Debug 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> Debug 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, K, L> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A> Debug for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B> Debug 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, L> Debug 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> Debug 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> Debug for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
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]
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]
impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
impl<Ret, A> Debug for unsafe fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Debug for unsafe fn(A, B, C) -> 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, 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> 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> Eq for fn(A, B, C, D, E, F, G, H) -> 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> Eq for fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
impl<Ret, A> Eq for unsafe fn(A) -> 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, 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> 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> 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> Eq for unsafe fn(A, B, C) -> 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> Eq for fn(A, B, C) -> 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> Eq for extern "C" fn(A, B, C, D, E) -> 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> 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> Eq for fn(A, B) -> 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> 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, 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, C, D> Eq for fn(A, B, C, D) -> 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, 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> 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, 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> 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 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, 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 extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret> Eq for unsafe fn() -> 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> Eq for 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, 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> Eq for extern "C" fn(A, B, C) -> 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> Eq for unsafe 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, 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, 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> Eq for fn(A, B, C, D, E, F) -> 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, 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, 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> Eq for fn() -> 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> 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> 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, 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> Eq for unsafe extern "C" fn(A, B, C, ...) -> 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, 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> Eq for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
impl<Ret> Eq for unsafe extern "C" fn() -> 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 unsafe 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 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 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> Eq for unsafe extern "C" 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, 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> 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 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, 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 fn(A, B, C, D, E, F, G, H, I, J, K) -> 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> Eq for fn(A) -> 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> Eq for unsafe fn(A, B) -> 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> 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> Eq for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E, F> Hash for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret> Hash for fn() -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B> Hash for fn(A, B) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C> Hash for fn(A, B, C) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C> Hash for unsafe fn(A, B, C) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D> Hash for unsafe fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D> Hash for fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E, F> Hash for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A> Hash for extern "C" fn(A) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E> Hash for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A> Hash for fn(A) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A> Hash for extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B> Hash for unsafe extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret> Hash for unsafe fn() -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E, F, G> Hash for fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E, F> Hash for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret> Hash for extern "C" fn() -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E> Hash for unsafe extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D> Hash for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B> Hash for extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A> Hash for unsafe extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C> Hash for unsafe extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C> Hash for extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A> Hash for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D, E> Hash for fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A> Hash for unsafe fn(A) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B> Hash for extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B> Hash for unsafe fn(A, B) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret> Hash for unsafe extern "C" fn() -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Ret, A, B, C, D> Hash for extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
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]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A> Ord for extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A> Ord for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn(A) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C> Ord for unsafe fn(A, B, C) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D> Ord for fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E> Ord for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B> Ord for fn(A, B) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E> Ord for fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A> Ord for fn(A) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret> Ord for extern "C" fn() -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn() -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret> Ord for unsafe fn() -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe fn() -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
[src]
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B> Ord for extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C> Ord for fn(A, B, C) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B, C) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret> Ord for unsafe extern "C" fn() -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D> Ord for unsafe fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret> Ord for fn() -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn() -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A> Ord for unsafe extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A> Ord for extern "C" fn(A) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B> Ord for extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
[src]
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
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]
pub fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Ordering
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret, A> Ord for unsafe fn(A) -> Ret
1.4.0[src]
pub fn cmp(&self, other: &unsafe fn(A) -> Ret) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn() -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialEq<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialEq<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret
1.4.0[src]
pub fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn() -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialEq<fn(A, B) -> Ret> for fn(A, B) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A, B) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret
1.4.0[src]
pub fn eq(&self, other: &fn(A) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialEq<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn() -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn() -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn eq(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> bool
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialEq<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialEq<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialEq<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialEq<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialEq<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A, B) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
1.4.0[src]
pub fn eq(&self, other: &unsafe fn(A) -> Ret) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &extern "C" fn() -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &extern "C" fn(A, B) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &extern "C" fn(A) -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &fn() -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &fn(A, B, C) -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn() -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn() -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
1.4.0[src]
pub 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]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub 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]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
1.4.0[src]
pub fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret
1.4.0[src]
pub fn partial_cmp(
&self,
other: &unsafe fn(A, B, C, D) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe fn(A, B, C, D) -> Ret
) -> Option<Ordering>