Trait nom::lib::std::prelude::v1::v1::PartialOrd 1.0.0
[−]
[src]
#[lang = "partial_ord"]pub trait PartialOrd<Rhs = Self>: PartialEq<Rhs> where
Rhs: ?Sized, { fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>; fn lt(&self, other: &Rhs) -> bool { ... } fn le(&self, other: &Rhs) -> bool { ... } fn gt(&self, other: &Rhs) -> bool { ... } fn ge(&self, other: &Rhs) -> bool { ... } }
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 } }
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 } }
Examples
let x : u32 = 0; let y : u32 = 1; assert_eq!(x < y, true); assert_eq!(x.lt(&y), true);
Required Methods
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));
When comparison is impossible:
let result = std::f64::NAN.partial_cmp(&1.0); assert_eq!(result, None);
Provided Methods
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);
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);
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);
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator.
Examples
let result = 2.0 >= 1.0; assert_eq!(result, true); let result = 2.0 >= 2.0; assert_eq!(result, true);
Implementations on Foreign Types
impl<'a, 'b> PartialOrd<PathBuf> for OsString
[src]
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf
[src]
impl<'a, 'b> PartialOrd<&'a Path> for OsString
[src]
impl<'a, 'b> PartialOrd<OsString> for Path
[src]
impl PartialOrd<SystemTime> for SystemTime
[src]
fn partial_cmp(&self, __arg_0: &SystemTime) -> Option<Ordering>
[src]
fn lt(&self, __arg_0: &SystemTime) -> bool
[src]
fn le(&self, __arg_0: &SystemTime) -> bool
[src]
fn gt(&self, __arg_0: &SystemTime) -> bool
[src]
fn ge(&self, __arg_0: &SystemTime) -> bool
[src]
impl PartialOrd<Ipv6Addr> for Ipv6Addr
[src]
impl<'a, 'b> PartialOrd<OsString> for &'a OsStr
[src]
impl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf
[src]
impl<'a, 'b> PartialOrd<OsString> for OsStr
[src]
impl<'a, 'b> PartialOrd<PathBuf> for &'a Path
[src]
impl<'a, 'b> PartialOrd<&'a Path> for OsStr
[src]
impl PartialOrd<str> for OsStr
[src]
impl PartialOrd<CStr> for CStr
[src]
impl<'a, 'b> PartialOrd<OsString> for PathBuf
[src]
impl PartialOrd<OsString> for OsString
[src]
impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>
[src]
impl<'a, 'b> PartialOrd<Path> for PathBuf
[src]
impl<'a, 'b> PartialOrd<OsStr> for PathBuf
[src]
impl PartialOrd<ErrorKind> for ErrorKind
[src]
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path
[src]
impl<'a, 'b> PartialOrd<OsStr> for OsString
[src]
impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>
[src]
impl<'a, 'b> PartialOrd<&'a Path> for PathBuf
[src]
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
[src]
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
[src]
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr
[src]
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString
[src]
impl PartialOrd<PathBuf> for PathBuf
[src]
impl<'a, 'b> PartialOrd<OsString> for &'a Path
[src]
impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>
[src]
impl PartialOrd<Path> for Path
[src]
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString
[src]
impl<'a, 'b> PartialOrd<&'a OsStr> for OsString
[src]
impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>
[src]
impl<'a, 'b> PartialOrd<PathBuf> for Path
[src]
impl PartialOrd<str> for OsString
[src]
impl PartialOrd<Instant> for Instant
[src]
impl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>
[src]
impl PartialOrd<OsStr> for OsStr
[src]
impl<'a> PartialOrd<Components<'a>> for Components<'a>
[src]
impl<'a, 'b> PartialOrd<Path> for &'a OsStr
[src]
impl<'a, 'b> PartialOrd<OsStr> for &'a Path
[src]
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr
[src]
impl PartialOrd<IpAddr> for Ipv6Addr
[src]
impl PartialOrd<Ipv4Addr> for IpAddr
[src]
impl<'a, 'b> PartialOrd<&'a OsStr> for Path
[src]
impl<'a, 'b> PartialOrd<OsStr> for Path
[src]
impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>
[src]
impl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>
[src]
impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr
[src]
impl<'a, 'b> PartialOrd<Path> for OsString
[src]
impl PartialOrd<IpAddr> for IpAddr
[src]
impl PartialOrd<Ipv4Addr> for Ipv4Addr
[src]
impl<'a, 'b> PartialOrd<PathBuf> for OsStr
[src]
impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>
[src]
impl PartialOrd<IpAddr> for Ipv4Addr
[src]
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for PathBuf
[src]
impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path
[src]
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path
[src]
impl PartialOrd<CString> for CString
[src]
impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>
[src]
impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>
[src]
impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>
[src]
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr
[src]
impl<'a, 'b> PartialOrd<Path> for OsStr
[src]
impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>
[src]
impl<'a> PartialOrd<Component<'a>> for Component<'a>
[src]
impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>
[src]
impl PartialOrd<Ipv6Addr> for IpAddr
[src]
impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>
[src]
impl<T> PartialOrd<[T; 6]> for [T; 6] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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, 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 PartialOrd<b8x64> for b8x64
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
[src]
impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
[src]
T: ?Sized,
impl<T> PartialOrd<[T; 0]> for [T; 0] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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 PartialOrd<f32x2> for f32x2
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret
[src]
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<T> PartialOrd<[T; 17]> for [T; 17] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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]
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
[src]
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T> PartialOrd<[T; 14]> for [T; 14] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<u32x4> for u32x4
[src]
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret
[src]
impl PartialOrd<u16x8> for u16x8
[src]
impl<T> PartialOrd<[T; 27]> for [T; 27] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<!> for !
[src]
impl<T> PartialOrd<[T; 29]> for [T; 29] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<T> PartialOrd<[T; 19]> for [T; 19] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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 PartialOrd<u64> for u64
[src]
impl PartialOrd<char> for char
[src]
impl<T> PartialOrd<[T; 11]> for [T; 11] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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 PartialOrd<()> for ()
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
[src]
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 PartialOrd<i128> for i128
[src]
impl PartialOrd<i64x8> for i64x8
[src]
impl PartialOrd<u16> for u16
[src]
impl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret
[src]
impl PartialOrd<i16> for i16
[src]
impl PartialOrd<u16x16> for u16x16
[src]
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
[src]
impl PartialOrd<i32x2> for i32x2
[src]
impl<T> PartialOrd<[T; 2]> for [T; 2] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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<T> PartialOrd<[T; 13]> for [T; 13] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<i32x16> for i32x16
[src]
impl PartialOrd<i8x16> for i8x16
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
[src]
impl<T> PartialOrd<[T; 4]> for [T; 4] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
[src]
impl<T> PartialOrd<Cell<T>> for Cell<T> where
T: Copy + PartialOrd<T>,
[src]
T: Copy + PartialOrd<T>,
impl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
[src]
T: ?Sized,
impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret
[src]
impl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> PartialOrd<[T; 26]> for [T; 26] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<T> PartialOrd<[T; 30]> for [T; 30] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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 PartialOrd<u8x16> for u8x16
[src]
impl<A, B, C, D, E, F, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G> + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G)) -> Option<Ordering>
[src]
fn lt(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool
[src]
impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret
[src]
impl PartialOrd<b8x32> for b8x32
[src]
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> 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
[src]
impl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
[src]
impl<T> PartialOrd<NonZero<T>> for NonZero<T> where
T: Zeroable + PartialOrd<T>,
[src]
T: Zeroable + PartialOrd<T>,
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, 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> PartialOrd<fn(A, B, C, D, E, F, G) -> Ret> for fn(A, B, C, D, E, F, G) -> Ret
[src]
impl PartialOrd<i8x2> for i8x2
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<unsafe fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(A, B, C, D, E, F, G) -> Ret
[src]
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> PartialOrd<fn() -> Ret> for fn() -> Ret
[src]
impl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret
[src]
impl PartialOrd<i16x16> for i16x16
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
[src]
impl PartialOrd<u8> for u8
[src]
impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret
[src]
impl PartialOrd<u32> for u32
[src]
impl<T> PartialOrd<[T; 12]> for [T; 12] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<T> PartialOrd<[T; 9]> for [T; 9] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<u128> for u128
[src]
impl PartialOrd<i16x2> for i16x2
[src]
impl<T> PartialOrd<[T]> for [T] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
Implements comparison of vectors lexicographically.
impl<A, B, C, D, E, F, G, H, I, J, K, 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
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I>,
J: PartialEq<J> + PartialOrd<J>,
K: PartialEq<K> + PartialOrd<K>,
L: PartialEq<L> + PartialOrd<L> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I>,
J: PartialEq<J> + PartialOrd<J>,
K: PartialEq<K> + PartialOrd<K>,
L: PartialEq<L> + PartialOrd<L> + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K, L)
) -> Option<Ordering>
[src]
&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 le(&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
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret
[src]
impl PartialOrd<b8x4> for b8x4
[src]
impl PartialOrd<u64x4> for u64x4
[src]
impl<T> PartialOrd<[T; 15]> for [T; 15] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<CpuidResult> for CpuidResult
[src]
fn partial_cmp(&self, __arg_0: &CpuidResult) -> Option<Ordering>
[src]
fn lt(&self, __arg_0: &CpuidResult) -> bool
[src]
fn le(&self, __arg_0: &CpuidResult) -> bool
[src]
fn gt(&self, __arg_0: &CpuidResult) -> bool
[src]
fn ge(&self, __arg_0: &CpuidResult) -> bool
[src]
impl<A, B, C, D, E, F, G, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H> + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Option<Ordering>
[src]
fn lt(&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
[src]
fn ge(&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
[src]
impl PartialOrd<u16x32> for u16x32
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
impl<T> PartialOrd<[T; 31]> for [T; 31] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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<A, B> PartialOrd<(A, B)> for (A, B) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B> + ?Sized,
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<T> PartialOrd<[T; 7]> for [T; 7] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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, 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<T> PartialOrd<[T; 32]> for [T; 32] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<i8x32> for i8x32
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
impl PartialOrd<u32x8> for u32x8
[src]
impl PartialOrd<i8x8> for i8x8
[src]
impl<T> PartialOrd<[T; 20]> for [T; 20] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<T> PartialOrd<[T; 25]> for [T; 25] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<'a, 'b, A, B> PartialOrd<&'b B> for &'a A where
A: PartialOrd<B> + ?Sized,
B: ?Sized,
[src]
A: PartialOrd<B> + ?Sized,
B: ?Sized,
impl PartialOrd<i64> for i64
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J) -> Ret
[src]
impl<T> PartialOrd<[T; 3]> for [T; 3] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D> + ?Sized,
impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret
[src]
impl PartialOrd<i64x2> for i64x2
[src]
impl PartialOrd<i64x4> for i64x4
[src]
impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E> + ?Sized,
impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F> + ?Sized,
impl PartialOrd<isize> for isize
[src]
impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
[src]
impl PartialOrd<bool> for bool
[src]
impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> 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
[src]
impl PartialOrd<u8x64> for u8x64
[src]
impl<Ret, A, B, C, D, E> PartialOrd<extern "C" fn(A, B, C, D, E) -> Ret> for extern "C" fn(A, B, C, D, E) -> Ret
[src]
impl PartialOrd<u16x2> for u16x2
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<fn(A, B, C, D, E, F) -> Ret> for fn(A, B, C, D, E, F) -> Ret
[src]
impl PartialOrd<u8x2> for u8x2
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
[src]
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> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
[src]
impl PartialOrd<f32x16> for f32x16
[src]
impl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret
[src]
impl<T> PartialOrd<[T; 22]> for [T; 22] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<T> PartialOrd<[T; 21]> for [T; 21] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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<T> PartialOrd<[T; 24]> for [T; 24] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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<T> PartialOrd<[T; 23]> for [T; 23] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<u64x8> for u64x8
[src]
impl PartialOrd<u32x16> for u32x16
[src]
impl PartialOrd<u16x4> for u16x4
[src]
impl<Ret, A, B, C, D, E> PartialOrd<unsafe extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(A, B, C, D, E) -> Ret
[src]
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> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
[src]
impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
[src]
impl PartialOrd<i8> for i8
[src]
impl<T> PartialOrd<[T; 16]> for [T; 16] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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<T> PartialOrd<[T; 5]> for [T; 5] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
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 PartialOrd<i32x8> for i32x8
[src]
impl PartialOrd<f64x2> for f64x2
[src]
impl PartialOrd<u32x2> for u32x2
[src]
impl PartialOrd<u8x8> for u8x8
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
[src]
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> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
[src]
impl PartialOrd<f32> for f32
[src]
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
[src]
impl PartialOrd<b8x8> for b8x8
[src]
impl PartialOrd<u8x32> for u8x32
[src]
impl PartialOrd<i16x8> for i16x8
[src]
impl PartialOrd<i8x64> for i8x64
[src]
impl PartialOrd<u8x4> for u8x4
[src]
impl<A, B, C, D, E, F, G, H, I, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I>,
J: PartialEq<J> + PartialOrd<J> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I>,
J: PartialEq<J> + PartialOrd<J> + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J)
) -> Option<Ordering>
[src]
&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 le(&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
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
[src]
impl<'a, 'b, A, B> PartialOrd<&'b mut B> for &'a mut A where
A: PartialOrd<B> + ?Sized,
B: ?Sized,
[src]
A: PartialOrd<B> + ?Sized,
B: ?Sized,
impl PartialOrd<i8x4> for i8x4
[src]
impl<A, B, C, D, E, F, G, H, I, J, 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
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I>,
J: PartialEq<J> + PartialOrd<J>,
K: PartialEq<K> + PartialOrd<K> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I>,
J: PartialEq<J> + PartialOrd<J>,
K: PartialEq<K> + PartialOrd<K> + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K)
) -> Option<Ordering>
[src]
&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 le(&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
[src]
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe fn(A, B, C, D, E, F) -> Ret> for unsafe fn(A, B, C, D, E, F) -> Ret
[src]
impl PartialOrd<TypeId> for TypeId
[src]
impl<T> PartialOrd<RefCell<T>> for RefCell<T> where
T: PartialOrd<T> + ?Sized,
[src]
T: PartialOrd<T> + ?Sized,
fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>
[src]
Panics
Panics if the value in either RefCell
is currently borrowed.
fn lt(&self, other: &RefCell<T>) -> bool
[src]
Panics
Panics if the value in either RefCell
is currently borrowed.
fn le(&self, other: &RefCell<T>) -> bool
[src]
Panics
Panics if the value in either RefCell
is currently borrowed.
fn gt(&self, other: &RefCell<T>) -> bool
[src]
Panics
Panics if the value in either RefCell
is currently borrowed.
fn ge(&self, other: &RefCell<T>) -> bool
[src]
Panics
Panics if the value in either RefCell
is currently borrowed.
impl<A> PartialOrd<(A,)> for (A,) where
A: PartialEq<A> + PartialOrd<A> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A> + ?Sized,
impl PartialOrd<i32x4> for i32x4
[src]
impl<Ret, A, B, C, D, E, F> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
[src]
impl<T> PartialOrd<[T; 1]> for [T; 1] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<b8x2> for b8x2
[src]
impl<Ret, A, B, C, D, E> PartialOrd<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret
[src]
impl PartialOrd<Duration> for Duration
[src]
impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
[src]
impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
T: ?Sized,
[src]
T: ?Sized,
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 PartialOrd<usize> for usize
[src]
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
[src]
impl PartialOrd<f32x4> for f32x4
[src]
impl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
[src]
impl PartialOrd<f64x4> for f64x4
[src]
impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C> + ?Sized,
impl PartialOrd<b8x16> for b8x16
[src]
impl<A, B, C, D, E, F, G, H, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I> + ?Sized,
[src]
A: PartialEq<A> + PartialOrd<A>,
B: PartialEq<B> + PartialOrd<B>,
C: PartialEq<C> + PartialOrd<C>,
D: PartialEq<D> + PartialOrd<D>,
E: PartialEq<E> + PartialOrd<E>,
F: PartialEq<F> + PartialOrd<F>,
G: PartialEq<G> + PartialOrd<G>,
H: PartialEq<H> + PartialOrd<H>,
I: PartialEq<I> + PartialOrd<I> + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Option<Ordering>
[src]
fn lt(&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
[src]
fn ge(&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
[src]
impl PartialOrd<i16x32> for i16x32
[src]
impl PartialOrd<f64> for f64
[src]
impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
[src]
impl<T> PartialOrd<[T; 8]> for [T; 8] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<u64x2> for u64x2
[src]
impl<Ret, A, B, C, D, E, F, G, H> PartialOrd<unsafe fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(A, B, C, D, E, F, G, H) -> Ret
[src]
impl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret
[src]
impl PartialOrd<i32> for i32
[src]
impl PartialOrd<f32x8> for f32x8
[src]
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
[src]
impl<T> PartialOrd<[T; 18]> for [T; 18] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<str> for str
[src]
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.
impl<T> PartialOrd<[T; 28]> for [T; 28] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl PartialOrd<i16x4> for i16x4
[src]
impl PartialOrd<f64x8> for f64x8
[src]
impl<T> PartialOrd<[T; 10]> for [T; 10] where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> 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
[src]
impl<T> PartialOrd<Rc<T>> for Rc<T> where
T: PartialOrd<T> + ?Sized,
[src]
T: PartialOrd<T> + ?Sized,
fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>
[src]
Partial comparison for two Rc
s.
The two are compared by calling partial_cmp()
on their inner values.
Examples
use std::rc::Rc; use std::cmp::Ordering; let five = Rc::new(5); assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6)));
fn lt(&self, other: &Rc<T>) -> bool
[src]
Less-than comparison for two Rc
s.
The two are compared by calling <
on their inner values.
Examples
use std::rc::Rc; let five = Rc::new(5); assert!(five < Rc::new(6));
fn le(&self, other: &Rc<T>) -> bool
[src]
'Less than or equal to' comparison for two Rc
s.
The two are compared by calling <=
on their inner values.
Examples
use std::rc::Rc; let five = Rc::new(5); assert!(five <= Rc::new(5));
fn gt(&self, other: &Rc<T>) -> bool
[src]
Greater-than comparison for two Rc
s.
The two are compared by calling >
on their inner values.
Examples
use std::rc::Rc; let five = Rc::new(5); assert!(five > Rc::new(4));
fn ge(&self, other: &Rc<T>) -> bool
[src]
'Greater than or equal to' comparison for two Rc
s.
The two are compared by calling >=
on their inner values.
Examples
use std::rc::Rc; let five = Rc::new(5); assert!(five >= Rc::new(5));
impl<T> PartialOrd<Arc<T>> for Arc<T> where
T: PartialOrd<T> + ?Sized,
[src]
T: PartialOrd<T> + ?Sized,
fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>
[src]
Partial comparison for two Arc
s.
The two are compared by calling partial_cmp()
on their inner values.
Examples
use std::sync::Arc; use std::cmp::Ordering; let five = Arc::new(5); assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));
fn lt(&self, other: &Arc<T>) -> bool
[src]
Less-than comparison for two Arc
s.
The two are compared by calling <
on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); assert!(five < Arc::new(6));
fn le(&self, other: &Arc<T>) -> bool
[src]
'Less than or equal to' comparison for two Arc
s.
The two are compared by calling <=
on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); assert!(five <= Arc::new(5));
fn gt(&self, other: &Arc<T>) -> bool
[src]
Greater-than comparison for two Arc
s.
The two are compared by calling >
on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); assert!(five > Arc::new(4));
fn ge(&self, other: &Arc<T>) -> bool
[src]
'Greater than or equal to' comparison for two Arc
s.
The two are compared by calling >=
on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); assert!(five >= Arc::new(5));
impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
B: PartialOrd<B> + ToOwned + ?Sized,
[src]
B: PartialOrd<B> + ToOwned + ?Sized,
impl PartialOrd<UnicodeVersion> for UnicodeVersion
[src]
fn partial_cmp(&self, __arg_0: &UnicodeVersion) -> Option<Ordering>
[src]
fn lt(&self, __arg_0: &UnicodeVersion) -> bool
[src]
fn le(&self, __arg_0: &UnicodeVersion) -> bool
[src]
fn gt(&self, __arg_0: &UnicodeVersion) -> bool
[src]
fn ge(&self, __arg_0: &UnicodeVersion) -> bool
[src]
Implementors
impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
R: PartialOrd<R>,
Y: PartialOrd<Y>,impl PartialOrd<NoneError> for NoneError
impl PartialOrd<Infallible> for Infallible
impl<T> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialOrd<T>,impl<T> PartialOrd<Option<T>> for Option<T> where
T: PartialOrd<T>,impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
E: PartialOrd<E>,
T: PartialOrd<T>,impl PartialOrd<Error> for Error
impl PartialOrd<Ordering> for Ordering
impl<T> PartialOrd<Reverse<T>> for Reverse<T> where
T: PartialOrd<T>,impl PartialOrd<String> for String
impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,impl<T> PartialOrd<Vec<T>> for Vec<T> where
T: PartialOrd<T>,impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
A: PartialOrd<A>,impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
T: PartialOrd<T>,impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialOrd<K>,
V: PartialOrd<V>,impl<T> PartialOrd<Box<T>> for Box<T> where
T: PartialOrd<T> + ?Sized,