1.0.0[−]Primitive Type fn
Function pointers, like fn(usize) -> bool
.
See also the traits Fn
, FnMut
, and FnOnce
.
Function pointers are pointers that point to code, not data. They can be called
just like functions. Like references, function pointers are, among other things, assumed to
not be null, so if you want to pass a function pointer over FFI and be able to accommodate null
pointers, make your type Option<fn()>
with your required signature.
Plain function pointers are obtained by casting either plain functions, or closures that don't capture an environment:
fn add_one(x: usize) -> usize { x + 1 } let ptr: fn(usize) -> usize = add_one; assert_eq!(ptr(5), 6); let clos: fn(usize) -> usize = |x| x + 5; assert_eq!(clos(5), 10);Run
In addition to varying based on their signature, function pointers come in two flavors: safe
and unsafe. Plain fn()
function pointers can only point to safe functions,
while unsafe fn()
function pointers can point to safe or unsafe functions.
fn add_one(x: usize) -> usize { x + 1 } unsafe fn add_one_unsafely(x: usize) -> usize { x + 1 } let safe_ptr: fn(usize) -> usize = add_one; //ERROR: mismatched types: expected normal fn, found unsafe fn //let bad_ptr: fn(usize) -> usize = add_one_unsafely; let unsafe_ptr: unsafe fn(usize) -> usize = add_one_unsafely; let really_safe_ptr: unsafe fn(usize) -> usize = add_one;Run
On top of that, function pointers can vary based on what ABI they use. This is achieved by
adding the extern
keyword to the type name, followed by the ABI in question. For example,
fn()
is different from extern "C" fn()
, which itself is different from extern "stdcall" fn()
, and so on for the various ABIs that Rust supports. Non-extern
functions have an ABI
of "Rust"
, and extern
functions without an explicit ABI have an ABI of "C"
. For more
information, see the nomicon's section on foreign calling conventions.
Extern function declarations with the "C" or "cdecl" ABIs can also be variadic, allowing them
to be called with a variable number of arguments. Normal rust functions, even those with an
extern "ABI"
, cannot be variadic. For more information, see the nomicon's section on
variadic functions.
These markers can be combined, so unsafe extern "stdcall" fn()
is a valid type.
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> Debug for extern "C" fn(A) -> 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> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> 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> Debug for extern "C" fn(A, B, C, D, VaListImpl) -> 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> Debug for unsafe extern "C" fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret, A, B> Debug for unsafe extern "C" fn(A, B, VaListImpl) -> 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, I> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Debug for unsafe extern "C" fn(A, B, C, VaListImpl) -> 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, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A> Debug for unsafe extern "C" fn(A, VaListImpl) -> 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, VaListImpl) -> 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, A, B, C> Debug for extern "C" fn(A, B, C) -> 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> Debug for fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A> Debug for unsafe fn(A) -> 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, B, C, D, E, F, G, H> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> 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> Debug for extern "C" fn(A, B, VaListImpl) -> 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, 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> Debug for 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, VaListImpl) -> Ret
1.4.0[src]
impl<Ret> Debug for unsafe extern "C" fn() -> 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 unsafe fn(A, B, C, D) -> 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, VaListImpl) -> 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> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A> Debug for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
impl<Ret, A> Debug for extern "C" fn(A, VaListImpl) -> 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> Debug for extern "C" fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Debug for unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> 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> Debug for extern "C" fn(A, B, C, D, E, F, G, H) -> 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 unsafe extern "C" fn(A, B, C, D, E) -> 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, VaListImpl) -> 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, 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, VaListImpl) -> 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, 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 fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Debug for extern "C" fn(A, B, C, VaListImpl) -> 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, D> Debug for unsafe extern "C" fn(A, B, C, D, VaListImpl) -> 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> Debug for unsafe fn() -> 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, 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 extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> 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> Debug for fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Debug for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> 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, VaListImpl) -> Ret
1.4.0[src]
impl<Ret> Debug for fn() -> 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, 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, 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, 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> Debug for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> 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 fn(A, B, C, D, E, F) -> 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> 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, H, I, J> Debug for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> 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> Debug for unsafe fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Debug for extern "C" fn(A, B, C, D, E, F, VaListImpl) -> 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, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Hash for extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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, VaListImpl) -> Ret
1.4.0[src]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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]
fn hash<HH>(&self, state: &mut HH) where
HH: Hasher,
[src]
HH: Hasher,
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> Eq for unsafe fn(A, B, C, D, E, F, G) -> 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> Eq for unsafe fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Eq for fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret, A, B> Eq for unsafe extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Eq for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret> Eq for extern "C" fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C> Eq for unsafe extern "C" fn(A, B, C, VaListImpl) -> 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, 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> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> 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> Eq for unsafe fn(A, B, C, D, E, F, G, H, I) -> 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 fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Eq for unsafe extern "C" fn(A, B, C) -> 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> 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> Eq for extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
impl<Ret> Eq for fn() -> 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> Eq for unsafe 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, E, F> Eq for unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> 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> Eq for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Eq for extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A> Eq for extern "C" fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Eq for fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Eq for extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A> Eq for unsafe fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Eq for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Eq for extern "C" fn(A, B, C, D, E, VaListImpl) -> 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, VaListImpl) -> 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> 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 extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B> Eq for unsafe fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A> Eq for unsafe extern "C" fn(A, VaListImpl) -> 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, VaListImpl) -> 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, B, C, D, E, F, G, H, I, J, K, L> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> 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 extern "C" fn(A, B, VaListImpl) -> 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, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Eq for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, 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, E> Eq for fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for unsafe 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> 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> Eq for extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Eq for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Eq for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret> Eq for unsafe extern "C" fn() -> Ret
1.4.0[src]
impl<Ret, A> Eq for extern "C" fn(A, VaListImpl) -> 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, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A> Eq for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Eq for fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> 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 extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Eq for unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Eq for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Eq for unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Eq for unsafe extern "C" fn(A, B, C, D, VaListImpl) -> 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> Eq for 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, B, C, D> Eq for extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A> Pointer for unsafe fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Pointer for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Pointer 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> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B> Pointer for extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret> Pointer for unsafe extern "C" fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Pointer for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Pointer for fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Pointer for unsafe fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Pointer for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B> Pointer for unsafe fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Pointer for fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
impl<Ret> Pointer for fn() -> Ret
1.4.0[src]
impl<Ret, A> Pointer for extern "C" fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
impl<Ret> Pointer for extern "C" fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Pointer for fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Pointer for fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret, A> Pointer for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
impl<Ret, A> Pointer for extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Pointer for unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B> Pointer for extern "C" fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Pointer for fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret> Pointer for unsafe fn() -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A> Pointer for unsafe extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A> Pointer for fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Pointer for unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D> Pointer for unsafe fn(A, B, C, D) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E> Pointer for extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B> Pointer for fn(A, B) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
impl<Ret, A, B, C> Pointer 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> Pointer 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> Pointer for extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
impl<Ret, A, B, C, D, E, F> Pointer for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
1.4.0[src]
fn eq(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> bool
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool
[src]
#[must_use]
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]
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]
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]
fn eq(&self, other: &unsafe fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> bool
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<unsafe extern "C" fn(A, VaListImpl) -> Ret> for unsafe extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &unsafe extern "C" fn(A, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<fn(A) -> Ret> for fn(A) -> Ret
1.4.0[src]
impl<Ret, A, B> PartialEq<extern "C" fn(A, B, VaListImpl) -> Ret> for extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &extern "C" fn(A, B, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &fn(A, B) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialEq<extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> bool
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
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]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialEq<unsafe extern "C" fn(A, B, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &unsafe extern "C" fn(A, B, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> bool
[src]
#[must_use]
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]
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]
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]
fn eq(&self, other: &unsafe fn(A, B) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> bool
[src]
#[must_use]
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]
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]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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]
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]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialEq<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
1.4.0[src]
fn eq(&self, other: &extern "C" fn() -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> bool
[src]
#[must_use]
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]
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]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> bool
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<extern "C" fn(A, B, C, D, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &extern "C" fn(A, B, C, D, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialEq<unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &unsafe extern "C" fn() -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialEq<fn() -> Ret> for fn() -> Ret
1.4.0[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]
fn eq(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> bool
[src]
#[must_use]
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]
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]
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]
fn eq(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialEq<unsafe fn() -> Ret> for unsafe fn() -> Ret
1.4.0[src]
fn eq(&self, other: &unsafe fn() -> Ret) -> bool
[src]
#[must_use]
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]
fn eq(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> bool
[src]
#[must_use]
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]
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]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &fn(A, B, C) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> bool
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &unsafe extern "C" fn(A) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<extern "C" fn(A, VaListImpl) -> Ret> for extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &extern "C" fn(A, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialEq<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
1.4.0[src]
fn eq(&self, other: &unsafe fn(A) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> bool
#[must_use]
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]
fn eq(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialEq<extern "C" fn(A, B, C, VaListImpl) -> Ret> for extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
fn eq(&self, other: &extern "C" fn(A, B, C, VaListImpl) -> Ret) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
fn eq(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> bool
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> bool
#[must_use]
fn ne(&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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, VaListImpl) -> Ret> for extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, VaListImpl) -> Ret> for extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<extern "C" fn(A, VaListImpl) -> Ret> for extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &extern "C" fn(A) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret
1.4.0[src]
fn partial_cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, VaListImpl) -> Ret> for unsafe extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
1.4.0[src]
fn partial_cmp(&self, other: &extern "C" fn() -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret
1.4.0[src]
fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
1.4.0[src]
fn partial_cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &fn(A, B, C) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret
1.4.0[src]
fn partial_cmp(&self, other: &fn() -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
1.4.0[src]
fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
fn partial_cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
1.4.0[src]
fn partial_cmp(&self, other: &unsafe fn(A) -> Ret) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret> for extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
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]
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]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn(A, B, C) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
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
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C, VaListImpl) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A> Ord for unsafe extern "C" fn(A) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn(A) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A> Ord for extern "C" fn(A) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G> Ord for unsafe fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D> Ord for unsafe fn(A, B, C, D) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B, C, D) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A> Ord for unsafe extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn(A, VaListImpl) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D> Ord for fn(A, B, C, D) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D> Ord for unsafe extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C> Ord for unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A> Ord for unsafe fn(A) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C, D) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
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
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E> Ord for fn(A, B, C, D, E) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret> Ord for unsafe extern "C" fn() -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C> Ord for unsafe fn(A, B, C) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E> Ord for unsafe fn(A, B, C, D, E) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B, C, D, E) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E> Ord for unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B> Ord for unsafe extern "C" fn(A, B) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe extern "C" fn(A, B) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
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
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F> Ord for extern "C" fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F> Ord for unsafe fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B> Ord for unsafe fn(A, B) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret> Ord for extern "C" fn() -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn() -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E> Ord for extern "C" fn(A, B, C, D, E) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C, D, E) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
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
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H> Ord for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B> Ord for fn(A, B) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A> Ord for extern "C" fn(A, VaListImpl) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, VaListImpl) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B> Ord for extern "C" fn(A, B, VaListImpl) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, VaListImpl) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C> Ord for extern "C" fn(A, B, C) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
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
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F> Ord for unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E, F, G, H, I) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
1.4.0[src]
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
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A> Ord for fn(A) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G> Ord for fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E, F, G) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F> Ord for fn(A, B, C, D, E, F) -> Ret
1.4.0[src]
fn cmp(&self, other: &fn(A, B, C, D, E, F) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G> Ord for extern "C" fn(A, B, C, D, E, F, G) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D> Ord for extern "C" fn(A, B, C, D, VaListImpl) -> Ret
1.4.0[src]
fn cmp(&self, other: &extern "C" fn(A, B, C, D, VaListImpl) -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Ord for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
1.4.0[src]
fn cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Ordering
[src]
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, VaListImpl) -> Ret
) -> Ordering
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret> Ord for unsafe fn() -> Ret
1.4.0[src]
fn cmp(&self, other: &unsafe fn() -> Ret) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> Ord for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
1.4.0[src]
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