1.0.0[−][src]Trait core::cmp::PartialOrd
Trait for values that can be compared for a sort-order.
The comparison must satisfy, for all a
, b
and c
:
- antisymmetry: if
a < b
then!(a > b)
, as well asa > b
implying!(a < b)
; and - transitivity:
a < b
andb < c
impliesa < c
. The same must hold for both==
and>
.
Note that these requirements mean that the trait itself must be implemented symmetrically and
transitively: if T: PartialOrd<U>
and U: PartialOrd<V>
then U: PartialOrd<T>
and T: PartialOrd<V>
.
Derivable
This trait can be used with #[derive]
. When derive
d on structs, it will produce a
lexicographic ordering based on the top-to-bottom declaration order of the struct's members.
When derive
d on enums, variants are ordered by their top-to-bottom declaration order.
How can I implement PartialOrd
?
PartialOrd
only requires implementation of the partial_cmp
method, with the others
generated from default implementations.
However it remains possible to implement the others separately for types which do not have a
total order. For example, for floating point numbers, NaN < 0 == false
and NaN >= 0 == false
(cf. IEEE 754-2008 section 5.11).
PartialOrd
requires your type to be PartialEq
.
Implementations of PartialEq
, PartialOrd
, and Ord
must agree with each other. It's
easy to accidentally make them disagree by deriving some of the traits and manually
implementing others.
If your type is Ord
, you can implement partial_cmp()
by using cmp()
:
use std::cmp::Ordering; #[derive(Eq)] struct Person { id: u32, name: String, height: u32, } impl PartialOrd for Person { fn partial_cmp(&self, other: &Person) -> Option<Ordering> { Some(self.cmp(other)) } } impl Ord for Person { fn cmp(&self, other: &Person) -> Ordering { self.height.cmp(&other.height) } } impl PartialEq for Person { fn eq(&self, other: &Person) -> bool { self.height == other.height } }Run
You may also find it useful to use partial_cmp()
on your type's fields. Here
is an example of Person
types who have a floating-point height
field that
is the only field to be used for sorting:
use std::cmp::Ordering; struct Person { id: u32, name: String, height: f64, } impl PartialOrd for Person { fn partial_cmp(&self, other: &Person) -> Option<Ordering> { self.height.partial_cmp(&other.height) } } impl PartialEq for Person { fn eq(&self, other: &Person) -> bool { self.height == other.height } }Run
Examples
let x : u32 = 0; let y : u32 = 1; assert_eq!(x < y, true); assert_eq!(x.lt(&y), true);Run
Required Methods
#[must_use]
fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists.
Examples
use std::cmp::Ordering; let result = 1.0.partial_cmp(&2.0); assert_eq!(result, Some(Ordering::Less)); let result = 1.0.partial_cmp(&1.0); assert_eq!(result, Some(Ordering::Equal)); let result = 2.0.partial_cmp(&1.0); assert_eq!(result, Some(Ordering::Greater));Run
When comparison is impossible:
let result = std::f64::NAN.partial_cmp(&1.0); assert_eq!(result, None);Run
Provided Methods
#[must_use]
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator.
Examples
let result = 1.0 < 2.0; assert_eq!(result, true); let result = 2.0 < 1.0; assert_eq!(result, false);Run
#[must_use]
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator.
Examples
let result = 1.0 <= 2.0; assert_eq!(result, true); let result = 2.0 <= 2.0; assert_eq!(result, true);Run
#[must_use]
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator.
Examples
let result = 1.0 > 2.0; assert_eq!(result, false); let result = 2.0 > 2.0; assert_eq!(result, false);Run
#[must_use]
fn ge(&self, other: &Rhs) -> bool
Implementors
impl PartialOrd<!> for !
[src]
impl PartialOrd<!> for !
fn partial_cmp(&self, _: &!) -> Option<Ordering>
[src]
fn partial_cmp(&self, _: &!) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<()> for ()
[src]
impl PartialOrd<()> for ()
fn partial_cmp(&self, _: &()) -> Option<Ordering>
[src]
fn partial_cmp(&self, _: &()) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<Ordering> for Ordering
[src]
impl PartialOrd<Ordering> for Ordering
fn partial_cmp(&self, other: &Ordering) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Ordering) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<TypeId> for TypeId
[src]
impl PartialOrd<TypeId> for TypeId
fn partial_cmp(&self, other: &TypeId) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &TypeId) -> Option<Ordering>
fn lt(&self, other: &TypeId) -> bool
[src]
fn lt(&self, other: &TypeId) -> bool
fn le(&self, other: &TypeId) -> bool
[src]
fn le(&self, other: &TypeId) -> bool
fn gt(&self, other: &TypeId) -> bool
[src]
fn gt(&self, other: &TypeId) -> bool
fn ge(&self, other: &TypeId) -> bool
[src]
fn ge(&self, other: &TypeId) -> bool
impl PartialOrd<CpuidResult> for CpuidResult
[src]
impl PartialOrd<CpuidResult> for CpuidResult
fn partial_cmp(&self, other: &CpuidResult) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &CpuidResult) -> Option<Ordering>
fn lt(&self, other: &CpuidResult) -> bool
[src]
fn lt(&self, other: &CpuidResult) -> bool
fn le(&self, other: &CpuidResult) -> bool
[src]
fn le(&self, other: &CpuidResult) -> bool
fn gt(&self, other: &CpuidResult) -> bool
[src]
fn gt(&self, other: &CpuidResult) -> bool
fn ge(&self, other: &CpuidResult) -> bool
[src]
fn ge(&self, other: &CpuidResult) -> bool
impl PartialOrd<UnicodeVersion> for UnicodeVersion
[src]
impl PartialOrd<UnicodeVersion> for UnicodeVersion
fn partial_cmp(&self, other: &UnicodeVersion) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &UnicodeVersion) -> Option<Ordering>
fn lt(&self, other: &UnicodeVersion) -> bool
[src]
fn lt(&self, other: &UnicodeVersion) -> bool
fn le(&self, other: &UnicodeVersion) -> bool
[src]
fn le(&self, other: &UnicodeVersion) -> bool
fn gt(&self, other: &UnicodeVersion) -> bool
[src]
fn gt(&self, other: &UnicodeVersion) -> bool
fn ge(&self, other: &UnicodeVersion) -> bool
[src]
fn ge(&self, other: &UnicodeVersion) -> bool
impl PartialOrd<Error> for Error
[src]
impl PartialOrd<Error> for Error
fn partial_cmp(&self, other: &Error) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Error) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<Pinned> for Pinned
[src]
impl PartialOrd<Pinned> for Pinned
fn partial_cmp(&self, other: &Pinned) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Pinned) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<NonZeroU128> for NonZeroU128
[src]
impl PartialOrd<NonZeroU128> for NonZeroU128
fn partial_cmp(&self, other: &NonZeroU128) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &NonZeroU128) -> Option<Ordering>
fn lt(&self, other: &NonZeroU128) -> bool
[src]
fn lt(&self, other: &NonZeroU128) -> bool
fn le(&self, other: &NonZeroU128) -> bool
[src]
fn le(&self, other: &NonZeroU128) -> bool
fn gt(&self, other: &NonZeroU128) -> bool
[src]
fn gt(&self, other: &NonZeroU128) -> bool
fn ge(&self, other: &NonZeroU128) -> bool
[src]
fn ge(&self, other: &NonZeroU128) -> bool
impl PartialOrd<NonZeroU16> for NonZeroU16
[src]
impl PartialOrd<NonZeroU16> for NonZeroU16
fn partial_cmp(&self, other: &NonZeroU16) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &NonZeroU16) -> Option<Ordering>
fn lt(&self, other: &NonZeroU16) -> bool
[src]
fn lt(&self, other: &NonZeroU16) -> bool
fn le(&self, other: &NonZeroU16) -> bool
[src]
fn le(&self, other: &NonZeroU16) -> bool
fn gt(&self, other: &NonZeroU16) -> bool
[src]
fn gt(&self, other: &NonZeroU16) -> bool
fn ge(&self, other: &NonZeroU16) -> bool
[src]
fn ge(&self, other: &NonZeroU16) -> bool
impl PartialOrd<NonZeroU32> for NonZeroU32
[src]
impl PartialOrd<NonZeroU32> for NonZeroU32
fn partial_cmp(&self, other: &NonZeroU32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &NonZeroU32) -> Option<Ordering>
fn lt(&self, other: &NonZeroU32) -> bool
[src]
fn lt(&self, other: &NonZeroU32) -> bool
fn le(&self, other: &NonZeroU32) -> bool
[src]
fn le(&self, other: &NonZeroU32) -> bool
fn gt(&self, other: &NonZeroU32) -> bool
[src]
fn gt(&self, other: &NonZeroU32) -> bool
fn ge(&self, other: &NonZeroU32) -> bool
[src]
fn ge(&self, other: &NonZeroU32) -> bool
impl PartialOrd<NonZeroU64> for NonZeroU64
[src]
impl PartialOrd<NonZeroU64> for NonZeroU64
fn partial_cmp(&self, other: &NonZeroU64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &NonZeroU64) -> Option<Ordering>
fn lt(&self, other: &NonZeroU64) -> bool
[src]
fn lt(&self, other: &NonZeroU64) -> bool
fn le(&self, other: &NonZeroU64) -> bool
[src]
fn le(&self, other: &NonZeroU64) -> bool
fn gt(&self, other: &NonZeroU64) -> bool
[src]
fn gt(&self, other: &NonZeroU64) -> bool
fn ge(&self, other: &NonZeroU64) -> bool
[src]
fn ge(&self, other: &NonZeroU64) -> bool
impl PartialOrd<NonZeroU8> for NonZeroU8
[src]
impl PartialOrd<NonZeroU8> for NonZeroU8
fn partial_cmp(&self, other: &NonZeroU8) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &NonZeroU8) -> Option<Ordering>
fn lt(&self, other: &NonZeroU8) -> bool
[src]
fn lt(&self, other: &NonZeroU8) -> bool
fn le(&self, other: &NonZeroU8) -> bool
[src]
fn le(&self, other: &NonZeroU8) -> bool
fn gt(&self, other: &NonZeroU8) -> bool
[src]
fn gt(&self, other: &NonZeroU8) -> bool
fn ge(&self, other: &NonZeroU8) -> bool
[src]
fn ge(&self, other: &NonZeroU8) -> bool
impl PartialOrd<NonZeroUsize> for NonZeroUsize
[src]
impl PartialOrd<NonZeroUsize> for NonZeroUsize
fn partial_cmp(&self, other: &NonZeroUsize) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &NonZeroUsize) -> Option<Ordering>
fn lt(&self, other: &NonZeroUsize) -> bool
[src]
fn lt(&self, other: &NonZeroUsize) -> bool
fn le(&self, other: &NonZeroUsize) -> bool
[src]
fn le(&self, other: &NonZeroUsize) -> bool
fn gt(&self, other: &NonZeroUsize) -> bool
[src]
fn gt(&self, other: &NonZeroUsize) -> bool
fn ge(&self, other: &NonZeroUsize) -> bool
[src]
fn ge(&self, other: &NonZeroUsize) -> bool
impl PartialOrd<NoneError> for NoneError
[src]
impl PartialOrd<NoneError> for NoneError
fn partial_cmp(&self, other: &NoneError) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &NoneError) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<Duration> for Duration
[src]
impl PartialOrd<Duration> for Duration
fn partial_cmp(&self, other: &Duration) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Duration) -> Option<Ordering>
fn lt(&self, other: &Duration) -> bool
[src]
fn lt(&self, other: &Duration) -> bool
fn le(&self, other: &Duration) -> bool
[src]
fn le(&self, other: &Duration) -> bool
fn gt(&self, other: &Duration) -> bool
[src]
fn gt(&self, other: &Duration) -> bool
fn ge(&self, other: &Duration) -> bool
[src]
fn ge(&self, other: &Duration) -> bool
impl PartialOrd<bool> for bool
[src]
impl PartialOrd<bool> for bool
fn partial_cmp(&self, other: &bool) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &bool) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<char> for char
[src]
impl PartialOrd<char> for char
fn partial_cmp(&self, other: &char) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &char) -> Option<Ordering>
fn lt(&self, other: &char) -> bool
[src]
fn lt(&self, other: &char) -> bool
fn le(&self, other: &char) -> bool
[src]
fn le(&self, other: &char) -> bool
fn ge(&self, other: &char) -> bool
[src]
fn ge(&self, other: &char) -> bool
fn gt(&self, other: &char) -> bool
[src]
fn gt(&self, other: &char) -> bool
impl PartialOrd<f32> for f32
[src]
impl PartialOrd<f32> for f32
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
fn lt(&self, other: &f32) -> bool
[src]
fn lt(&self, other: &f32) -> bool
fn le(&self, other: &f32) -> bool
[src]
fn le(&self, other: &f32) -> bool
fn ge(&self, other: &f32) -> bool
[src]
fn ge(&self, other: &f32) -> bool
fn gt(&self, other: &f32) -> bool
[src]
fn gt(&self, other: &f32) -> bool
impl PartialOrd<f64> for f64
[src]
impl PartialOrd<f64> for f64
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
fn lt(&self, other: &f64) -> bool
[src]
fn lt(&self, other: &f64) -> bool
fn le(&self, other: &f64) -> bool
[src]
fn le(&self, other: &f64) -> bool
fn ge(&self, other: &f64) -> bool
[src]
fn ge(&self, other: &f64) -> bool
fn gt(&self, other: &f64) -> bool
[src]
fn gt(&self, other: &f64) -> bool
impl PartialOrd<i128> for i128
[src]
impl PartialOrd<i128> for i128
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
fn lt(&self, other: &i128) -> bool
[src]
fn lt(&self, other: &i128) -> bool
fn le(&self, other: &i128) -> bool
[src]
fn le(&self, other: &i128) -> bool
fn ge(&self, other: &i128) -> bool
[src]
fn ge(&self, other: &i128) -> bool
fn gt(&self, other: &i128) -> bool
[src]
fn gt(&self, other: &i128) -> bool
impl PartialOrd<i16> for i16
[src]
impl PartialOrd<i16> for i16
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
fn lt(&self, other: &i16) -> bool
[src]
fn lt(&self, other: &i16) -> bool
fn le(&self, other: &i16) -> bool
[src]
fn le(&self, other: &i16) -> bool
fn ge(&self, other: &i16) -> bool
[src]
fn ge(&self, other: &i16) -> bool
fn gt(&self, other: &i16) -> bool
[src]
fn gt(&self, other: &i16) -> bool
impl PartialOrd<i32> for i32
[src]
impl PartialOrd<i32> for i32
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
fn lt(&self, other: &i32) -> bool
[src]
fn lt(&self, other: &i32) -> bool
fn le(&self, other: &i32) -> bool
[src]
fn le(&self, other: &i32) -> bool
fn ge(&self, other: &i32) -> bool
[src]
fn ge(&self, other: &i32) -> bool
fn gt(&self, other: &i32) -> bool
[src]
fn gt(&self, other: &i32) -> bool
impl PartialOrd<i64> for i64
[src]
impl PartialOrd<i64> for i64
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
fn lt(&self, other: &i64) -> bool
[src]
fn lt(&self, other: &i64) -> bool
fn le(&self, other: &i64) -> bool
[src]
fn le(&self, other: &i64) -> bool
fn ge(&self, other: &i64) -> bool
[src]
fn ge(&self, other: &i64) -> bool
fn gt(&self, other: &i64) -> bool
[src]
fn gt(&self, other: &i64) -> bool
impl PartialOrd<i8> for i8
[src]
impl PartialOrd<i8> for i8
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
fn lt(&self, other: &i8) -> bool
[src]
fn lt(&self, other: &i8) -> bool
fn le(&self, other: &i8) -> bool
[src]
fn le(&self, other: &i8) -> bool
fn ge(&self, other: &i8) -> bool
[src]
fn ge(&self, other: &i8) -> bool
fn gt(&self, other: &i8) -> bool
[src]
fn gt(&self, other: &i8) -> bool
impl PartialOrd<isize> for isize
[src]
impl PartialOrd<isize> for isize
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
fn lt(&self, other: &isize) -> bool
[src]
fn lt(&self, other: &isize) -> bool
fn le(&self, other: &isize) -> bool
[src]
fn le(&self, other: &isize) -> bool
fn ge(&self, other: &isize) -> bool
[src]
fn ge(&self, other: &isize) -> bool
fn gt(&self, other: &isize) -> bool
[src]
fn gt(&self, other: &isize) -> bool
impl PartialOrd<str> for str
[src]
impl PartialOrd<str> for str
Implements comparison operations on strings.
Strings are compared lexicographically by their byte values. This compares Unicode code
points based on their positions in the code charts. This is not necessarily the same as
"alphabetical" order, which varies by language and locale. Comparing strings according to
culturally-accepted standards requires locale-specific data that is outside the scope of
the str
type.
fn partial_cmp(&self, other: &str) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &str) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl PartialOrd<u128> for u128
[src]
impl PartialOrd<u128> for u128
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
fn lt(&self, other: &u128) -> bool
[src]
fn lt(&self, other: &u128) -> bool
fn le(&self, other: &u128) -> bool
[src]
fn le(&self, other: &u128) -> bool
fn ge(&self, other: &u128) -> bool
[src]
fn ge(&self, other: &u128) -> bool
fn gt(&self, other: &u128) -> bool
[src]
fn gt(&self, other: &u128) -> bool
impl PartialOrd<u16> for u16
[src]
impl PartialOrd<u16> for u16
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
fn lt(&self, other: &u16) -> bool
[src]
fn lt(&self, other: &u16) -> bool
fn le(&self, other: &u16) -> bool
[src]
fn le(&self, other: &u16) -> bool
fn ge(&self, other: &u16) -> bool
[src]
fn ge(&self, other: &u16) -> bool
fn gt(&self, other: &u16) -> bool
[src]
fn gt(&self, other: &u16) -> bool
impl PartialOrd<u32> for u32
[src]
impl PartialOrd<u32> for u32
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
fn lt(&self, other: &u32) -> bool
[src]
fn lt(&self, other: &u32) -> bool
fn le(&self, other: &u32) -> bool
[src]
fn le(&self, other: &u32) -> bool
fn ge(&self, other: &u32) -> bool
[src]
fn ge(&self, other: &u32) -> bool
fn gt(&self, other: &u32) -> bool
[src]
fn gt(&self, other: &u32) -> bool
impl PartialOrd<u64> for u64
[src]
impl PartialOrd<u64> for u64
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
fn lt(&self, other: &u64) -> bool
[src]
fn lt(&self, other: &u64) -> bool
fn le(&self, other: &u64) -> bool
[src]
fn le(&self, other: &u64) -> bool
fn ge(&self, other: &u64) -> bool
[src]
fn ge(&self, other: &u64) -> bool
fn gt(&self, other: &u64) -> bool
[src]
fn gt(&self, other: &u64) -> bool
impl PartialOrd<u8> for u8
[src]
impl PartialOrd<u8> for u8
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
fn lt(&self, other: &u8) -> bool
[src]
fn lt(&self, other: &u8) -> bool
fn le(&self, other: &u8) -> bool
[src]
fn le(&self, other: &u8) -> bool
fn ge(&self, other: &u8) -> bool
[src]
fn ge(&self, other: &u8) -> bool
fn gt(&self, other: &u8) -> bool
[src]
fn gt(&self, other: &u8) -> bool
impl PartialOrd<usize> for usize
[src]
impl PartialOrd<usize> for usize
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
fn lt(&self, other: &usize) -> bool
[src]
fn lt(&self, other: &usize) -> bool
fn le(&self, other: &usize) -> bool
[src]
fn le(&self, other: &usize) -> bool
fn ge(&self, other: &usize) -> bool
[src]
fn ge(&self, other: &usize) -> bool
fn gt(&self, other: &usize) -> bool
[src]
fn gt(&self, other: &usize) -> bool
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b B> for &'a A where
A: PartialOrd<B>,
[src]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b B> for &'a A where
A: PartialOrd<B>,
fn partial_cmp(&self, other: &&'b B) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &&'b B) -> Option<Ordering>
fn lt(&self, other: &&'b B) -> bool
[src]
fn lt(&self, other: &&'b B) -> bool
fn le(&self, other: &&'b B) -> bool
[src]
fn le(&self, other: &&'b B) -> bool
fn ge(&self, other: &&'b B) -> bool
[src]
fn ge(&self, other: &&'b B) -> bool
fn gt(&self, other: &&'b B) -> bool
[src]
fn gt(&self, other: &&'b B) -> bool
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b mut B> for &'a mut A where
A: PartialOrd<B>,
[src]
impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b mut B> for &'a mut A where
A: PartialOrd<B>,
fn partial_cmp(&self, other: &&'b mut B) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &&'b mut B) -> Option<Ordering>
fn lt(&self, other: &&'b mut B) -> bool
[src]
fn lt(&self, other: &&'b mut B) -> bool
fn le(&self, other: &&'b mut B) -> bool
[src]
fn le(&self, other: &&'b mut B) -> bool
fn ge(&self, other: &&'b mut B) -> bool
[src]
fn ge(&self, other: &&'b mut B) -> bool
fn gt(&self, other: &&'b mut B) -> bool
[src]
fn gt(&self, other: &&'b mut B) -> bool
impl<A> PartialOrd<(A,)> for (A,) where
A: PartialOrd + PartialEq + ?Sized,
[src]
impl<A> PartialOrd<(A,)> for (A,) where
A: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A,)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A,)) -> Option<Ordering>
fn lt(&self, other: &(A,)) -> bool
[src]
fn lt(&self, other: &(A,)) -> bool
fn le(&self, other: &(A,)) -> bool
[src]
fn le(&self, other: &(A,)) -> bool
fn ge(&self, other: &(A,)) -> bool
[src]
fn ge(&self, other: &(A,)) -> bool
fn gt(&self, other: &(A,)) -> bool
[src]
fn gt(&self, other: &(A,)) -> bool
impl<A: PartialOrd + PartialEq, B> PartialOrd<(A, B)> for (A, B) where
B: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B> PartialOrd<(A, B)> for (A, B) where
B: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B)) -> Option<Ordering>
fn lt(&self, other: &(A, B)) -> bool
[src]
fn lt(&self, other: &(A, B)) -> bool
fn le(&self, other: &(A, B)) -> bool
[src]
fn le(&self, other: &(A, B)) -> bool
fn ge(&self, other: &(A, B)) -> bool
[src]
fn ge(&self, other: &(A, B)) -> bool
fn gt(&self, other: &(A, B)) -> bool
[src]
fn gt(&self, other: &(A, B)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C> PartialOrd<(A, B, C)> for (A, B, C) where
C: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C> PartialOrd<(A, B, C)> for (A, B, C) where
C: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B, C)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B, C)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C)) -> bool
[src]
fn lt(&self, other: &(A, B, C)) -> bool
fn le(&self, other: &(A, B, C)) -> bool
[src]
fn le(&self, other: &(A, B, C)) -> bool
fn ge(&self, other: &(A, B, C)) -> bool
[src]
fn ge(&self, other: &(A, B, C)) -> bool
fn gt(&self, other: &(A, B, C)) -> bool
[src]
fn gt(&self, other: &(A, B, C)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
D: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
D: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B, C, D)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D)) -> bool
fn le(&self, other: &(A, B, C, D)) -> bool
[src]
fn le(&self, other: &(A, B, C, D)) -> bool
fn ge(&self, other: &(A, B, C, D)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D)) -> bool
fn gt(&self, other: &(A, B, C, D)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
E: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
E: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B, C, D, E)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E)) -> bool
fn le(&self, other: &(A, B, C, D, E)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E)) -> bool
fn ge(&self, other: &(A, B, C, D, E)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E)) -> bool
fn gt(&self, other: &(A, B, C, D, E)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
F: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
F: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B, C, D, E, F)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E, F)) -> bool
fn le(&self, other: &(A, B, C, D, E, F)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
G: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
G: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
H: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
H: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
I: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
I: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
J: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
J: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J)
) -> Option<Ordering>
[src]
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J)
) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
K: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
K: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K)
) -> Option<Ordering>
[src]
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K)
) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K: PartialOrd + PartialEq, L> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
L: PartialOrd + PartialEq + ?Sized,
[src]
impl<A: PartialOrd + PartialEq, B: PartialOrd + PartialEq, C: PartialOrd + PartialEq, D: PartialOrd + PartialEq, E: PartialOrd + PartialEq, F: PartialOrd + PartialEq, G: PartialOrd + PartialEq, H: PartialOrd + PartialEq, I: PartialOrd + PartialEq, J: PartialOrd + PartialEq, K: PartialOrd + PartialEq, L> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
L: PartialOrd + PartialEq + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K, L)
) -> Option<Ordering>
[src]
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K, L)
) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
[src]
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
impl<P: PartialOrd> PartialOrd<Pin<P>> for Pin<P>
[src]
impl<P: PartialOrd> PartialOrd<Pin<P>> for Pin<P>
fn partial_cmp(&self, other: &Pin<P>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Pin<P>) -> Option<Ordering>
fn lt(&self, other: &Pin<P>) -> bool
[src]
fn lt(&self, other: &Pin<P>) -> bool
fn le(&self, other: &Pin<P>) -> bool
[src]
fn le(&self, other: &Pin<P>) -> bool
fn gt(&self, other: &Pin<P>) -> bool
[src]
fn gt(&self, other: &Pin<P>) -> bool
fn ge(&self, other: &Pin<P>) -> bool
[src]
fn ge(&self, other: &Pin<P>) -> bool
impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
[src]
impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret
[src]
impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
[src]
impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
[src]
impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(_: A) -> Ret
[src]
impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(_: A) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(_: A, ...) -> Ret
[src]
impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(_: A, ...) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(_: A) -> Ret
[src]
impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(_: A) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(_: A) -> Ret
[src]
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(_: A) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(_: A, ...) -> Ret
[src]
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(_: A, ...) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(_: A) -> Ret
[src]
impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(_: A) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(_: A, _: B) -> Ret
[src]
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(_: A, _: B) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(_: A, _: B, ...) -> Ret
[src]
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(_: A, _: B, ...) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(_: A, _: B) -> Ret
[src]
impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(_: A, _: B) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(_: A, _: B) -> Ret
[src]
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(_: A, _: B) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, ...) -> Ret
[src]
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, ...) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(_: A, _: B) -> Ret
[src]
impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(_: A, _: B) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(_: A, _: B, _: C) -> Ret
[src]
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(_: A, _: B, _: C) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, ...) -> Ret
[src]
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, ...) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(_: A, _: B, _: C) -> Ret
[src]
impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(_: A, _: B, _: C) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret
[src]
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret
[src]
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(_: A, _: B, _: C) -> Ret
[src]
impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(_: A, _: B, _: C) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D) -> Ret
[src]
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret
[src]
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(_: A, _: B, _: C, _: D) -> Ret
[src]
impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(_: A, _: B, _: C, _: D) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D) -> Ret
[src]
impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E) -> Ret
[src]
impl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E) -> Ret
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E> PartialOrd<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F> PartialOrd<fn(A, B, C, D, E, F) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G> PartialOrd<fn(A, B, C, D, E, F, G) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<fn(A, B, C, D, E, F, G, H) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<fn(A, B, C, D, E, F, G, H, I) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret
[src]
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
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<T: PartialOrd + Copy> PartialOrd<Cell<T>> for Cell<T>
[src]
impl<T: PartialOrd + Copy> PartialOrd<Cell<T>> for Cell<T>
fn partial_cmp(&self, other: &Cell<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Cell<T>) -> Option<Ordering>
fn lt(&self, other: &Cell<T>) -> bool
[src]
fn lt(&self, other: &Cell<T>) -> bool
fn le(&self, other: &Cell<T>) -> bool
[src]
fn le(&self, other: &Cell<T>) -> bool
fn gt(&self, other: &Cell<T>) -> bool
[src]
fn gt(&self, other: &Cell<T>) -> bool
fn ge(&self, other: &Cell<T>) -> bool
[src]
fn ge(&self, other: &Cell<T>) -> bool
impl<T: PartialOrd + ?Sized> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T>
[src]
impl<T: PartialOrd + ?Sized> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T>
fn partial_cmp(&self, other: &ManuallyDrop<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &ManuallyDrop<T>) -> Option<Ordering>
fn lt(&self, other: &ManuallyDrop<T>) -> bool
[src]
fn lt(&self, other: &ManuallyDrop<T>) -> bool
fn le(&self, other: &ManuallyDrop<T>) -> bool
[src]
fn le(&self, other: &ManuallyDrop<T>) -> bool
fn gt(&self, other: &ManuallyDrop<T>) -> bool
[src]
fn gt(&self, other: &ManuallyDrop<T>) -> bool
fn ge(&self, other: &ManuallyDrop<T>) -> bool
[src]
fn ge(&self, other: &ManuallyDrop<T>) -> bool
impl<T: PartialOrd> PartialOrd<Option<T>> for Option<T>
[src]
impl<T: PartialOrd> PartialOrd<Option<T>> for Option<T>
fn partial_cmp(&self, other: &Option<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Option<T>) -> Option<Ordering>
fn lt(&self, other: &Option<T>) -> bool
[src]
fn lt(&self, other: &Option<T>) -> bool
fn le(&self, other: &Option<T>) -> bool
[src]
fn le(&self, other: &Option<T>) -> bool
fn gt(&self, other: &Option<T>) -> bool
[src]
fn gt(&self, other: &Option<T>) -> bool
fn ge(&self, other: &Option<T>) -> bool
[src]
fn ge(&self, other: &Option<T>) -> bool
impl<T: PartialOrd> PartialOrd<Poll<T>> for Poll<T>
[src]
impl<T: PartialOrd> PartialOrd<Poll<T>> for Poll<T>
fn partial_cmp(&self, other: &Poll<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Poll<T>) -> Option<Ordering>
fn lt(&self, other: &Poll<T>) -> bool
[src]
fn lt(&self, other: &Poll<T>) -> bool
fn le(&self, other: &Poll<T>) -> bool
[src]
fn le(&self, other: &Poll<T>) -> bool
fn gt(&self, other: &Poll<T>) -> bool
[src]
fn gt(&self, other: &Poll<T>) -> bool
fn ge(&self, other: &Poll<T>) -> bool
[src]
fn ge(&self, other: &Poll<T>) -> bool
impl<T: PartialOrd> PartialOrd<Reverse<T>> for Reverse<T>
[src]
impl<T: PartialOrd> PartialOrd<Reverse<T>> for Reverse<T>
fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering>
fn lt(&self, other: &Self) -> bool
[src]
fn lt(&self, other: &Self) -> bool
fn le(&self, other: &Self) -> bool
[src]
fn le(&self, other: &Self) -> bool
fn ge(&self, other: &Self) -> bool
[src]
fn ge(&self, other: &Self) -> bool
fn gt(&self, other: &Self) -> bool
[src]
fn gt(&self, other: &Self) -> bool
impl<T: PartialOrd> PartialOrd<Wrapping<T>> for Wrapping<T>
[src]
impl<T: PartialOrd> PartialOrd<Wrapping<T>> for Wrapping<T>
fn partial_cmp(&self, other: &Wrapping<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Wrapping<T>) -> Option<Ordering>
fn lt(&self, other: &Wrapping<T>) -> bool
[src]
fn lt(&self, other: &Wrapping<T>) -> bool
fn le(&self, other: &Wrapping<T>) -> bool
[src]
fn le(&self, other: &Wrapping<T>) -> bool
fn gt(&self, other: &Wrapping<T>) -> bool
[src]
fn gt(&self, other: &Wrapping<T>) -> bool
fn ge(&self, other: &Wrapping<T>) -> bool
[src]
fn ge(&self, other: &Wrapping<T>) -> bool
impl<T: PartialOrd> PartialOrd<[T; 0]> for [T; 0]
[src]
impl<T: PartialOrd> PartialOrd<[T; 0]> for [T; 0]
fn partial_cmp(&self, other: &[T; 0]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 0]) -> Option<Ordering>
fn lt(&self, other: &[T; 0]) -> bool
[src]
fn lt(&self, other: &[T; 0]) -> bool
fn le(&self, other: &[T; 0]) -> bool
[src]
fn le(&self, other: &[T; 0]) -> bool
fn ge(&self, other: &[T; 0]) -> bool
[src]
fn ge(&self, other: &[T; 0]) -> bool
fn gt(&self, other: &[T; 0]) -> bool
[src]
fn gt(&self, other: &[T; 0]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 10]> for [T; 10]
[src]
impl<T: PartialOrd> PartialOrd<[T; 10]> for [T; 10]
fn partial_cmp(&self, other: &[T; 10]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 10]) -> Option<Ordering>
fn lt(&self, other: &[T; 10]) -> bool
[src]
fn lt(&self, other: &[T; 10]) -> bool
fn le(&self, other: &[T; 10]) -> bool
[src]
fn le(&self, other: &[T; 10]) -> bool
fn ge(&self, other: &[T; 10]) -> bool
[src]
fn ge(&self, other: &[T; 10]) -> bool
fn gt(&self, other: &[T; 10]) -> bool
[src]
fn gt(&self, other: &[T; 10]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 11]> for [T; 11]
[src]
impl<T: PartialOrd> PartialOrd<[T; 11]> for [T; 11]
fn partial_cmp(&self, other: &[T; 11]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 11]) -> Option<Ordering>
fn lt(&self, other: &[T; 11]) -> bool
[src]
fn lt(&self, other: &[T; 11]) -> bool
fn le(&self, other: &[T; 11]) -> bool
[src]
fn le(&self, other: &[T; 11]) -> bool
fn ge(&self, other: &[T; 11]) -> bool
[src]
fn ge(&self, other: &[T; 11]) -> bool
fn gt(&self, other: &[T; 11]) -> bool
[src]
fn gt(&self, other: &[T; 11]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 12]> for [T; 12]
[src]
impl<T: PartialOrd> PartialOrd<[T; 12]> for [T; 12]
fn partial_cmp(&self, other: &[T; 12]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 12]) -> Option<Ordering>
fn lt(&self, other: &[T; 12]) -> bool
[src]
fn lt(&self, other: &[T; 12]) -> bool
fn le(&self, other: &[T; 12]) -> bool
[src]
fn le(&self, other: &[T; 12]) -> bool
fn ge(&self, other: &[T; 12]) -> bool
[src]
fn ge(&self, other: &[T; 12]) -> bool
fn gt(&self, other: &[T; 12]) -> bool
[src]
fn gt(&self, other: &[T; 12]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 13]> for [T; 13]
[src]
impl<T: PartialOrd> PartialOrd<[T; 13]> for [T; 13]
fn partial_cmp(&self, other: &[T; 13]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 13]) -> Option<Ordering>
fn lt(&self, other: &[T; 13]) -> bool
[src]
fn lt(&self, other: &[T; 13]) -> bool
fn le(&self, other: &[T; 13]) -> bool
[src]
fn le(&self, other: &[T; 13]) -> bool
fn ge(&self, other: &[T; 13]) -> bool
[src]
fn ge(&self, other: &[T; 13]) -> bool
fn gt(&self, other: &[T; 13]) -> bool
[src]
fn gt(&self, other: &[T; 13]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 14]> for [T; 14]
[src]
impl<T: PartialOrd> PartialOrd<[T; 14]> for [T; 14]
fn partial_cmp(&self, other: &[T; 14]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 14]) -> Option<Ordering>
fn lt(&self, other: &[T; 14]) -> bool
[src]
fn lt(&self, other: &[T; 14]) -> bool
fn le(&self, other: &[T; 14]) -> bool
[src]
fn le(&self, other: &[T; 14]) -> bool
fn ge(&self, other: &[T; 14]) -> bool
[src]
fn ge(&self, other: &[T; 14]) -> bool
fn gt(&self, other: &[T; 14]) -> bool
[src]
fn gt(&self, other: &[T; 14]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 15]> for [T; 15]
[src]
impl<T: PartialOrd> PartialOrd<[T; 15]> for [T; 15]
fn partial_cmp(&self, other: &[T; 15]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 15]) -> Option<Ordering>
fn lt(&self, other: &[T; 15]) -> bool
[src]
fn lt(&self, other: &[T; 15]) -> bool
fn le(&self, other: &[T; 15]) -> bool
[src]
fn le(&self, other: &[T; 15]) -> bool
fn ge(&self, other: &[T; 15]) -> bool
[src]
fn ge(&self, other: &[T; 15]) -> bool
fn gt(&self, other: &[T; 15]) -> bool
[src]
fn gt(&self, other: &[T; 15]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 16]> for [T; 16]
[src]
impl<T: PartialOrd> PartialOrd<[T; 16]> for [T; 16]
fn partial_cmp(&self, other: &[T; 16]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 16]) -> Option<Ordering>
fn lt(&self, other: &[T; 16]) -> bool
[src]
fn lt(&self, other: &[T; 16]) -> bool
fn le(&self, other: &[T; 16]) -> bool
[src]
fn le(&self, other: &[T; 16]) -> bool
fn ge(&self, other: &[T; 16]) -> bool
[src]
fn ge(&self, other: &[T; 16]) -> bool
fn gt(&self, other: &[T; 16]) -> bool
[src]
fn gt(&self, other: &[T; 16]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 17]> for [T; 17]
[src]
impl<T: PartialOrd> PartialOrd<[T; 17]> for [T; 17]
fn partial_cmp(&self, other: &[T; 17]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 17]) -> Option<Ordering>
fn lt(&self, other: &[T; 17]) -> bool
[src]
fn lt(&self, other: &[T; 17]) -> bool
fn le(&self, other: &[T; 17]) -> bool
[src]
fn le(&self, other: &[T; 17]) -> bool
fn ge(&self, other: &[T; 17]) -> bool
[src]
fn ge(&self, other: &[T; 17]) -> bool
fn gt(&self, other: &[T; 17]) -> bool
[src]
fn gt(&self, other: &[T; 17]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 18]> for [T; 18]
[src]
impl<T: PartialOrd> PartialOrd<[T; 18]> for [T; 18]
fn partial_cmp(&self, other: &[T; 18]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 18]) -> Option<Ordering>
fn lt(&self, other: &[T; 18]) -> bool
[src]
fn lt(&self, other: &[T; 18]) -> bool
fn le(&self, other: &[T; 18]) -> bool
[src]
fn le(&self, other: &[T; 18]) -> bool
fn ge(&self, other: &[T; 18]) -> bool
[src]
fn ge(&self, other: &[T; 18]) -> bool
fn gt(&self, other: &[T; 18]) -> bool
[src]
fn gt(&self, other: &[T; 18]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 19]> for [T; 19]
[src]
impl<T: PartialOrd> PartialOrd<[T; 19]> for [T; 19]
fn partial_cmp(&self, other: &[T; 19]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 19]) -> Option<Ordering>
fn lt(&self, other: &[T; 19]) -> bool
[src]
fn lt(&self, other: &[T; 19]) -> bool
fn le(&self, other: &[T; 19]) -> bool
[src]
fn le(&self, other: &[T; 19]) -> bool
fn ge(&self, other: &[T; 19]) -> bool
[src]
fn ge(&self, other: &[T; 19]) -> bool
fn gt(&self, other: &[T; 19]) -> bool
[src]
fn gt(&self, other: &[T; 19]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 1]> for [T; 1]
[src]
impl<T: PartialOrd> PartialOrd<[T; 1]> for [T; 1]
fn partial_cmp(&self, other: &[T; 1]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 1]) -> Option<Ordering>
fn lt(&self, other: &[T; 1]) -> bool
[src]
fn lt(&self, other: &[T; 1]) -> bool
fn le(&self, other: &[T; 1]) -> bool
[src]
fn le(&self, other: &[T; 1]) -> bool
fn ge(&self, other: &[T; 1]) -> bool
[src]
fn ge(&self, other: &[T; 1]) -> bool
fn gt(&self, other: &[T; 1]) -> bool
[src]
fn gt(&self, other: &[T; 1]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 20]> for [T; 20]
[src]
impl<T: PartialOrd> PartialOrd<[T; 20]> for [T; 20]
fn partial_cmp(&self, other: &[T; 20]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 20]) -> Option<Ordering>
fn lt(&self, other: &[T; 20]) -> bool
[src]
fn lt(&self, other: &[T; 20]) -> bool
fn le(&self, other: &[T; 20]) -> bool
[src]
fn le(&self, other: &[T; 20]) -> bool
fn ge(&self, other: &[T; 20]) -> bool
[src]
fn ge(&self, other: &[T; 20]) -> bool
fn gt(&self, other: &[T; 20]) -> bool
[src]
fn gt(&self, other: &[T; 20]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 21]> for [T; 21]
[src]
impl<T: PartialOrd> PartialOrd<[T; 21]> for [T; 21]
fn partial_cmp(&self, other: &[T; 21]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 21]) -> Option<Ordering>
fn lt(&self, other: &[T; 21]) -> bool
[src]
fn lt(&self, other: &[T; 21]) -> bool
fn le(&self, other: &[T; 21]) -> bool
[src]
fn le(&self, other: &[T; 21]) -> bool
fn ge(&self, other: &[T; 21]) -> bool
[src]
fn ge(&self, other: &[T; 21]) -> bool
fn gt(&self, other: &[T; 21]) -> bool
[src]
fn gt(&self, other: &[T; 21]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 22]> for [T; 22]
[src]
impl<T: PartialOrd> PartialOrd<[T; 22]> for [T; 22]
fn partial_cmp(&self, other: &[T; 22]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 22]) -> Option<Ordering>
fn lt(&self, other: &[T; 22]) -> bool
[src]
fn lt(&self, other: &[T; 22]) -> bool
fn le(&self, other: &[T; 22]) -> bool
[src]
fn le(&self, other: &[T; 22]) -> bool
fn ge(&self, other: &[T; 22]) -> bool
[src]
fn ge(&self, other: &[T; 22]) -> bool
fn gt(&self, other: &[T; 22]) -> bool
[src]
fn gt(&self, other: &[T; 22]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 23]> for [T; 23]
[src]
impl<T: PartialOrd> PartialOrd<[T; 23]> for [T; 23]
fn partial_cmp(&self, other: &[T; 23]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 23]) -> Option<Ordering>
fn lt(&self, other: &[T; 23]) -> bool
[src]
fn lt(&self, other: &[T; 23]) -> bool
fn le(&self, other: &[T; 23]) -> bool
[src]
fn le(&self, other: &[T; 23]) -> bool
fn ge(&self, other: &[T; 23]) -> bool
[src]
fn ge(&self, other: &[T; 23]) -> bool
fn gt(&self, other: &[T; 23]) -> bool
[src]
fn gt(&self, other: &[T; 23]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 24]> for [T; 24]
[src]
impl<T: PartialOrd> PartialOrd<[T; 24]> for [T; 24]
fn partial_cmp(&self, other: &[T; 24]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 24]) -> Option<Ordering>
fn lt(&self, other: &[T; 24]) -> bool
[src]
fn lt(&self, other: &[T; 24]) -> bool
fn le(&self, other: &[T; 24]) -> bool
[src]
fn le(&self, other: &[T; 24]) -> bool
fn ge(&self, other: &[T; 24]) -> bool
[src]
fn ge(&self, other: &[T; 24]) -> bool
fn gt(&self, other: &[T; 24]) -> bool
[src]
fn gt(&self, other: &[T; 24]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 25]> for [T; 25]
[src]
impl<T: PartialOrd> PartialOrd<[T; 25]> for [T; 25]
fn partial_cmp(&self, other: &[T; 25]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 25]) -> Option<Ordering>
fn lt(&self, other: &[T; 25]) -> bool
[src]
fn lt(&self, other: &[T; 25]) -> bool
fn le(&self, other: &[T; 25]) -> bool
[src]
fn le(&self, other: &[T; 25]) -> bool
fn ge(&self, other: &[T; 25]) -> bool
[src]
fn ge(&self, other: &[T; 25]) -> bool
fn gt(&self, other: &[T; 25]) -> bool
[src]
fn gt(&self, other: &[T; 25]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 26]> for [T; 26]
[src]
impl<T: PartialOrd> PartialOrd<[T; 26]> for [T; 26]
fn partial_cmp(&self, other: &[T; 26]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 26]) -> Option<Ordering>
fn lt(&self, other: &[T; 26]) -> bool
[src]
fn lt(&self, other: &[T; 26]) -> bool
fn le(&self, other: &[T; 26]) -> bool
[src]
fn le(&self, other: &[T; 26]) -> bool
fn ge(&self, other: &[T; 26]) -> bool
[src]
fn ge(&self, other: &[T; 26]) -> bool
fn gt(&self, other: &[T; 26]) -> bool
[src]
fn gt(&self, other: &[T; 26]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 27]> for [T; 27]
[src]
impl<T: PartialOrd> PartialOrd<[T; 27]> for [T; 27]
fn partial_cmp(&self, other: &[T; 27]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 27]) -> Option<Ordering>
fn lt(&self, other: &[T; 27]) -> bool
[src]
fn lt(&self, other: &[T; 27]) -> bool
fn le(&self, other: &[T; 27]) -> bool
[src]
fn le(&self, other: &[T; 27]) -> bool
fn ge(&self, other: &[T; 27]) -> bool
[src]
fn ge(&self, other: &[T; 27]) -> bool
fn gt(&self, other: &[T; 27]) -> bool
[src]
fn gt(&self, other: &[T; 27]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 28]> for [T; 28]
[src]
impl<T: PartialOrd> PartialOrd<[T; 28]> for [T; 28]
fn partial_cmp(&self, other: &[T; 28]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 28]) -> Option<Ordering>
fn lt(&self, other: &[T; 28]) -> bool
[src]
fn lt(&self, other: &[T; 28]) -> bool
fn le(&self, other: &[T; 28]) -> bool
[src]
fn le(&self, other: &[T; 28]) -> bool
fn ge(&self, other: &[T; 28]) -> bool
[src]
fn ge(&self, other: &[T; 28]) -> bool
fn gt(&self, other: &[T; 28]) -> bool
[src]
fn gt(&self, other: &[T; 28]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 29]> for [T; 29]
[src]
impl<T: PartialOrd> PartialOrd<[T; 29]> for [T; 29]
fn partial_cmp(&self, other: &[T; 29]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 29]) -> Option<Ordering>
fn lt(&self, other: &[T; 29]) -> bool
[src]
fn lt(&self, other: &[T; 29]) -> bool
fn le(&self, other: &[T; 29]) -> bool
[src]
fn le(&self, other: &[T; 29]) -> bool
fn ge(&self, other: &[T; 29]) -> bool
[src]
fn ge(&self, other: &[T; 29]) -> bool
fn gt(&self, other: &[T; 29]) -> bool
[src]
fn gt(&self, other: &[T; 29]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 2]> for [T; 2]
[src]
impl<T: PartialOrd> PartialOrd<[T; 2]> for [T; 2]
fn partial_cmp(&self, other: &[T; 2]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 2]) -> Option<Ordering>
fn lt(&self, other: &[T; 2]) -> bool
[src]
fn lt(&self, other: &[T; 2]) -> bool
fn le(&self, other: &[T; 2]) -> bool
[src]
fn le(&self, other: &[T; 2]) -> bool
fn ge(&self, other: &[T; 2]) -> bool
[src]
fn ge(&self, other: &[T; 2]) -> bool
fn gt(&self, other: &[T; 2]) -> bool
[src]
fn gt(&self, other: &[T; 2]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 30]> for [T; 30]
[src]
impl<T: PartialOrd> PartialOrd<[T; 30]> for [T; 30]
fn partial_cmp(&self, other: &[T; 30]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 30]) -> Option<Ordering>
fn lt(&self, other: &[T; 30]) -> bool
[src]
fn lt(&self, other: &[T; 30]) -> bool
fn le(&self, other: &[T; 30]) -> bool
[src]
fn le(&self, other: &[T; 30]) -> bool
fn ge(&self, other: &[T; 30]) -> bool
[src]
fn ge(&self, other: &[T; 30]) -> bool
fn gt(&self, other: &[T; 30]) -> bool
[src]
fn gt(&self, other: &[T; 30]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 31]> for [T; 31]
[src]
impl<T: PartialOrd> PartialOrd<[T; 31]> for [T; 31]
fn partial_cmp(&self, other: &[T; 31]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 31]) -> Option<Ordering>
fn lt(&self, other: &[T; 31]) -> bool
[src]
fn lt(&self, other: &[T; 31]) -> bool
fn le(&self, other: &[T; 31]) -> bool
[src]
fn le(&self, other: &[T; 31]) -> bool
fn ge(&self, other: &[T; 31]) -> bool
[src]
fn ge(&self, other: &[T; 31]) -> bool
fn gt(&self, other: &[T; 31]) -> bool
[src]
fn gt(&self, other: &[T; 31]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 32]> for [T; 32]
[src]
impl<T: PartialOrd> PartialOrd<[T; 32]> for [T; 32]
fn partial_cmp(&self, other: &[T; 32]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 32]) -> Option<Ordering>
fn lt(&self, other: &[T; 32]) -> bool
[src]
fn lt(&self, other: &[T; 32]) -> bool
fn le(&self, other: &[T; 32]) -> bool
[src]
fn le(&self, other: &[T; 32]) -> bool
fn ge(&self, other: &[T; 32]) -> bool
[src]
fn ge(&self, other: &[T; 32]) -> bool
fn gt(&self, other: &[T; 32]) -> bool
[src]
fn gt(&self, other: &[T; 32]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 3]> for [T; 3]
[src]
impl<T: PartialOrd> PartialOrd<[T; 3]> for [T; 3]
fn partial_cmp(&self, other: &[T; 3]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 3]) -> Option<Ordering>
fn lt(&self, other: &[T; 3]) -> bool
[src]
fn lt(&self, other: &[T; 3]) -> bool
fn le(&self, other: &[T; 3]) -> bool
[src]
fn le(&self, other: &[T; 3]) -> bool
fn ge(&self, other: &[T; 3]) -> bool
[src]
fn ge(&self, other: &[T; 3]) -> bool
fn gt(&self, other: &[T; 3]) -> bool
[src]
fn gt(&self, other: &[T; 3]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 4]> for [T; 4]
[src]
impl<T: PartialOrd> PartialOrd<[T; 4]> for [T; 4]
fn partial_cmp(&self, other: &[T; 4]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 4]) -> Option<Ordering>
fn lt(&self, other: &[T; 4]) -> bool
[src]
fn lt(&self, other: &[T; 4]) -> bool
fn le(&self, other: &[T; 4]) -> bool
[src]
fn le(&self, other: &[T; 4]) -> bool
fn ge(&self, other: &[T; 4]) -> bool
[src]
fn ge(&self, other: &[T; 4]) -> bool
fn gt(&self, other: &[T; 4]) -> bool
[src]
fn gt(&self, other: &[T; 4]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 5]> for [T; 5]
[src]
impl<T: PartialOrd> PartialOrd<[T; 5]> for [T; 5]
fn partial_cmp(&self, other: &[T; 5]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 5]) -> Option<Ordering>
fn lt(&self, other: &[T; 5]) -> bool
[src]
fn lt(&self, other: &[T; 5]) -> bool
fn le(&self, other: &[T; 5]) -> bool
[src]
fn le(&self, other: &[T; 5]) -> bool
fn ge(&self, other: &[T; 5]) -> bool
[src]
fn ge(&self, other: &[T; 5]) -> bool
fn gt(&self, other: &[T; 5]) -> bool
[src]
fn gt(&self, other: &[T; 5]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 6]> for [T; 6]
[src]
impl<T: PartialOrd> PartialOrd<[T; 6]> for [T; 6]
fn partial_cmp(&self, other: &[T; 6]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 6]) -> Option<Ordering>
fn lt(&self, other: &[T; 6]) -> bool
[src]
fn lt(&self, other: &[T; 6]) -> bool
fn le(&self, other: &[T; 6]) -> bool
[src]
fn le(&self, other: &[T; 6]) -> bool
fn ge(&self, other: &[T; 6]) -> bool
[src]
fn ge(&self, other: &[T; 6]) -> bool
fn gt(&self, other: &[T; 6]) -> bool
[src]
fn gt(&self, other: &[T; 6]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 7]> for [T; 7]
[src]
impl<T: PartialOrd> PartialOrd<[T; 7]> for [T; 7]
fn partial_cmp(&self, other: &[T; 7]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 7]) -> Option<Ordering>
fn lt(&self, other: &[T; 7]) -> bool
[src]
fn lt(&self, other: &[T; 7]) -> bool
fn le(&self, other: &[T; 7]) -> bool
[src]
fn le(&self, other: &[T; 7]) -> bool
fn ge(&self, other: &[T; 7]) -> bool
[src]
fn ge(&self, other: &[T; 7]) -> bool
fn gt(&self, other: &[T; 7]) -> bool
[src]
fn gt(&self, other: &[T; 7]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 8]> for [T; 8]
[src]
impl<T: PartialOrd> PartialOrd<[T; 8]> for [T; 8]
fn partial_cmp(&self, other: &[T; 8]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 8]) -> Option<Ordering>
fn lt(&self, other: &[T; 8]) -> bool
[src]
fn lt(&self, other: &[T; 8]) -> bool
fn le(&self, other: &[T; 8]) -> bool
[src]
fn le(&self, other: &[T; 8]) -> bool
fn ge(&self, other: &[T; 8]) -> bool
[src]
fn ge(&self, other: &[T; 8]) -> bool
fn gt(&self, other: &[T; 8]) -> bool
[src]
fn gt(&self, other: &[T; 8]) -> bool
impl<T: PartialOrd> PartialOrd<[T; 9]> for [T; 9]
[src]
impl<T: PartialOrd> PartialOrd<[T; 9]> for [T; 9]
fn partial_cmp(&self, other: &[T; 9]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T; 9]) -> Option<Ordering>
fn lt(&self, other: &[T; 9]) -> bool
[src]
fn lt(&self, other: &[T; 9]) -> bool
fn le(&self, other: &[T; 9]) -> bool
[src]
fn le(&self, other: &[T; 9]) -> bool
fn ge(&self, other: &[T; 9]) -> bool
[src]
fn ge(&self, other: &[T; 9]) -> bool
fn gt(&self, other: &[T; 9]) -> bool
[src]
fn gt(&self, other: &[T; 9]) -> bool
impl<T: PartialOrd> PartialOrd<[T]> for [T]
[src]
impl<T: PartialOrd> PartialOrd<[T]> for [T]
Implements comparison of vectors lexicographically.
fn partial_cmp(&self, other: &[T]) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &[T]) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<T: PartialOrd, E: PartialOrd> PartialOrd<Result<T, E>> for Result<T, E>
[src]
impl<T: PartialOrd, E: PartialOrd> PartialOrd<Result<T, E>> for Result<T, E>
fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>
fn lt(&self, other: &Result<T, E>) -> bool
[src]
fn lt(&self, other: &Result<T, E>) -> bool
fn le(&self, other: &Result<T, E>) -> bool
[src]
fn le(&self, other: &Result<T, E>) -> bool
fn gt(&self, other: &Result<T, E>) -> bool
[src]
fn gt(&self, other: &Result<T, E>) -> bool
fn ge(&self, other: &Result<T, E>) -> bool
[src]
fn ge(&self, other: &Result<T, E>) -> bool
impl<T: ?Sized + PartialOrd> PartialOrd<RefCell<T>> for RefCell<T>
[src]
impl<T: ?Sized + PartialOrd> PartialOrd<RefCell<T>> for RefCell<T>
fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>
Panics
Panics if the value in either RefCell
is currently borrowed.
fn lt(&self, other: &RefCell<T>) -> bool
[src]
fn lt(&self, other: &RefCell<T>) -> bool
Panics
Panics if the value in either RefCell
is currently borrowed.
fn le(&self, other: &RefCell<T>) -> bool
[src]
fn le(&self, other: &RefCell<T>) -> bool
Panics
Panics if the value in either RefCell
is currently borrowed.
fn gt(&self, other: &RefCell<T>) -> bool
[src]
fn gt(&self, other: &RefCell<T>) -> bool
Panics
Panics if the value in either RefCell
is currently borrowed.
fn ge(&self, other: &RefCell<T>) -> bool
[src]
fn ge(&self, other: &RefCell<T>) -> bool
Panics
Panics if the value in either RefCell
is currently borrowed.
impl<T: ?Sized> PartialOrd<*const T> for *const T
[src]
impl<T: ?Sized> PartialOrd<*const T> for *const T
fn partial_cmp(&self, other: &*const T) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &*const T) -> Option<Ordering>
fn lt(&self, other: &*const T) -> bool
[src]
fn lt(&self, other: &*const T) -> bool
fn le(&self, other: &*const T) -> bool
[src]
fn le(&self, other: &*const T) -> bool
fn gt(&self, other: &*const T) -> bool
[src]
fn gt(&self, other: &*const T) -> bool
fn ge(&self, other: &*const T) -> bool
[src]
fn ge(&self, other: &*const T) -> bool
impl<T: ?Sized> PartialOrd<*mut T> for *mut T
[src]
impl<T: ?Sized> PartialOrd<*mut T> for *mut T
fn partial_cmp(&self, other: &*mut T) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &*mut T) -> Option<Ordering>
fn lt(&self, other: &*mut T) -> bool
[src]
fn lt(&self, other: &*mut T) -> bool
fn le(&self, other: &*mut T) -> bool
[src]
fn le(&self, other: &*mut T) -> bool
fn gt(&self, other: &*mut T) -> bool
[src]
fn gt(&self, other: &*mut T) -> bool
fn ge(&self, other: &*mut T) -> bool
[src]
fn ge(&self, other: &*mut T) -> bool
impl<T: ?Sized> PartialOrd<PhantomData<T>> for PhantomData<T>
[src]
impl<T: ?Sized> PartialOrd<PhantomData<T>> for PhantomData<T>
fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<Ordering>
[src]
fn partial_cmp(&self, _other: &PhantomData<T>) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<T: ?Sized> PartialOrd<NonNull<T>> for NonNull<T>
[src]
impl<T: ?Sized> PartialOrd<NonNull<T>> for NonNull<T>
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
impl<Y: PartialOrd, R: PartialOrd> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R>
[src]
impl<Y: PartialOrd, R: PartialOrd> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R>
fn partial_cmp(&self, other: &GeneratorState<Y, R>) -> Option<Ordering>
[src]
fn partial_cmp(&self, other: &GeneratorState<Y, R>) -> Option<Ordering>
fn lt(&self, other: &GeneratorState<Y, R>) -> bool
[src]
fn lt(&self, other: &GeneratorState<Y, R>) -> bool
fn le(&self, other: &GeneratorState<Y, R>) -> bool
[src]
fn le(&self, other: &GeneratorState<Y, R>) -> bool
fn gt(&self, other: &GeneratorState<Y, R>) -> bool
[src]
fn gt(&self, other: &GeneratorState<Y, R>) -> bool
fn ge(&self, other: &GeneratorState<Y, R>) -> bool
[src]
fn ge(&self, other: &GeneratorState<Y, R>) -> bool