Trait otter_api_tests::cmp::PartialOrd
1.0.0 · source · [−]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 { ... }
}
Expand description
Trait for types that form a partial order.
The lt
, le
, gt
, and ge
methods of this trait can be called using
the <
, <=
, >
, and >=
operators, respectively.
The methods of this trait must be consistent with each other and with those of PartialEq
.
The following conditions must hold:
a == b
if and only ifpartial_cmp(a, b) == Some(Equal)
.a < b
if and only ifpartial_cmp(a, b) == Some(Less)
a > b
if and only ifpartial_cmp(a, b) == Some(Greater)
a <= b
if and only ifa < b || a == b
a >= b
if and only ifa > b || a == b
a != b
if and only if!(a == b)
.
Conditions 2–5 above are ensured by the default implementation.
Condition 6 is already ensured by PartialEq
.
If Ord
is also implemented for Self
and Rhs
, it must also be consistent with
partial_cmp
(see the documentation of that trait for the exact requirements). It’s
easy to accidentally make them disagree by deriving some of the traits and manually
implementing others.
The comparison must satisfy, for all a
, b
and c
:
- transitivity:
a < b
andb < c
impliesa < c
. The same must hold for both==
and>
. - duality:
a < b
if and only ifb > a
.
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>
.
Corollaries
The following corollaries follow from the above requirements:
- irreflexivity of
<
and>
:!(a < a)
,!(a > a)
- transitivity of
>
: ifa > b
andb > c
thena > c
- duality of
partial_cmp
:partial_cmp(a, b) == partial_cmp(b, a).map(Ordering::reverse)
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 discriminants.
By default, the discriminant is smallest for variants at the top, and
largest for variants at the bottom. Here’s an example:
#[derive(PartialEq, PartialOrd)]
enum E {
Top,
Bottom,
}
assert!(E::Top < E::Bottom);
However, manually setting the discriminants can override this default behavior:
#[derive(PartialEq, PartialOrd)]
enum E {
Top = 2,
Bottom = 1,
}
assert!(E::Bottom < E::Top);
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
.
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: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Person {
fn cmp(&self, other: &Self) -> Ordering {
self.height.cmp(&other.height)
}
}
impl PartialEq for Person {
fn eq(&self, other: &Self) -> 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: &Self) -> Option<Ordering> {
self.height.partial_cmp(&other.height)
}
}
impl PartialEq for Person {
fn eq(&self, other: &Self) -> 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>
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 = f64::NAN.partial_cmp(&1.0);
assert_eq!(result, None);
Provided methods
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);
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);
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);
Implementations on Foreign Types
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'a OsStr> for OsString
impl<'a, 'b> PartialOrd<&'a OsStr> for OsString
fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'a OsStr> for Path
impl<'a, 'b> PartialOrd<&'a OsStr> for Path
fn partial_cmp(&self, other: &&'a OsStr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'a Path> for OsString
impl<'a, 'b> PartialOrd<&'a Path> for OsString
fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Path> for OsString
impl<'a, 'b> PartialOrd<Path> for OsString
fn partial_cmp(&self, other: &Path) -> Option<Ordering>
sourceimpl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>
impl<'a> PartialOrd<PrefixComponent<'a>> for PrefixComponent<'a>
fn partial_cmp(&self, other: &PrefixComponent<'a>) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString
sourceimpl<'a> PartialOrd<Component<'a>> for Component<'a>
impl<'a> PartialOrd<Component<'a>> for Component<'a>
fn partial_cmp(&self, other: &Component<'a>) -> Option<Ordering>
sourceimpl PartialOrd<CString> for CString
impl PartialOrd<CString> for CString
fn partial_cmp(&self, other: &CString) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<PathBuf> for OsString
impl<'a, 'b> PartialOrd<PathBuf> for OsString
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for &'a Path
impl<'a, 'b> PartialOrd<OsString> for &'a Path
fn partial_cmp(&self, other: &OsString) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path
1.45.0 · sourceimpl PartialOrd<SocketAddrV4> for SocketAddrV4
impl PartialOrd<SocketAddrV4> for SocketAddrV4
fn partial_cmp(&self, other: &SocketAddrV4) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsStr> for Path
impl<'a, 'b> PartialOrd<OsStr> for Path
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsStr> for &'a Path
impl<'a, 'b> PartialOrd<OsStr> for &'a Path
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
sourceimpl PartialOrd<Path> for Path
impl PartialOrd<Path> for Path
fn partial_cmp(&self, other: &Path) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
sourceimpl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>
impl<'a> PartialOrd<Prefix<'a>> for Prefix<'a>
fn partial_cmp(&self, other: &Prefix<'a>) -> Option<Ordering>
sourceimpl PartialOrd<str> for OsString
impl PartialOrd<str> for OsString
fn partial_cmp(&self, other: &str) -> Option<Ordering>
sourceimpl PartialOrd<CStr> for CStr
impl PartialOrd<CStr> for CStr
fn partial_cmp(&self, other: &CStr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<PathBuf> for &'a Path
impl<'a, 'b> PartialOrd<PathBuf> for &'a Path
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for Path
impl<'a, 'b> PartialOrd<OsString> for Path
fn partial_cmp(&self, other: &OsString) -> Option<Ordering>
sourceimpl PartialOrd<OsString> for OsString
impl PartialOrd<OsString> for OsString
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path
impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path
sourceimpl<'a> PartialOrd<Components<'a>> for Components<'a>
impl<'a> PartialOrd<Components<'a>> for Components<'a>
fn partial_cmp(&self, other: &Components<'a>) -> Option<Ordering>
1.45.0 · sourceimpl PartialOrd<SocketAddrV6> for SocketAddrV6
impl PartialOrd<SocketAddrV6> for SocketAddrV6
fn partial_cmp(&self, other: &SocketAddrV6) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<PathBuf> for Path
impl<'a, 'b> PartialOrd<PathBuf> for Path
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsStr> for OsString
impl<'a, 'b> PartialOrd<OsStr> for OsString
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
fn partial_cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<i16> for i16
impl PartialOrd<i16> for i16
sourceimpl PartialOrd<()> for ()
impl PartialOrd<()> for ()
fn partial_cmp(&self, &()) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D, ...) -> Ret> for extern "C" fn(A, B, C, D, ...) -> Ret
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: &extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret
impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret
fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>
sourceimpl<A, B> PartialOrd<(A, B)> for (A, B) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B> + ?Sized,
impl<A, B> PartialOrd<(A, B)> for (A, B) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B> + ?Sized,
sourceimpl PartialOrd<u64> for u64
impl PartialOrd<u64> for u64
1.4.0 · sourceimpl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
impl<Ret> PartialOrd<unsafe extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret
fn partial_cmp(&self, other: &unsafe extern "C" fn() -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B) -> Ret> for extern "C" fn(A, B) -> Ret
fn partial_cmp(&self, other: &extern "C" fn(A, B) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>
sourceimpl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
impl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
1.4.0 · sourceimpl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret
impl<Ret, A> PartialOrd<extern "C" fn(A) -> Ret> for extern "C" fn(A) -> Ret
fn partial_cmp(&self, other: &extern "C" fn(A) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<i64> for i64
impl PartialOrd<i64> for i64
1.4.0 · sourceimpl<Ret, A, B, C, D, E> PartialOrd<unsafe fn(A, B, C, D, E) -> Ret> for unsafe fn(A, B, C, D, E) -> Ret
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: &unsafe fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
sourceimpl<T> PartialOrd<[T]> for [T] where
T: PartialOrd<T>,
impl<T> PartialOrd<[T]> for [T] where
T: PartialOrd<T>,
Implements comparison of vectors lexicographically.
fn partial_cmp(&self, other: &[T]) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C, ...) -> Ret> for extern "C" fn(A, B, C, ...) -> Ret
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: &extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &fn(A, B, C, D, E, F) -> Ret) -> Option<Ordering>
sourceimpl PartialOrd<isize> for isize
impl PartialOrd<isize> for isize
sourceimpl PartialOrd<i8> for i8
impl PartialOrd<i8> for i8
sourceimpl PartialOrd<str> for str
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>
sourceimpl<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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
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
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
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool
1.4.0 · sourceimpl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
impl<Ret> PartialOrd<extern "C" fn() -> Ret> for extern "C" fn() -> Ret
fn partial_cmp(&self, other: &extern "C" fn() -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<char> for char
impl PartialOrd<char> for char
1.4.0 · sourceimpl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
impl<Ret> PartialOrd<unsafe fn() -> Ret> for unsafe fn() -> Ret
fn partial_cmp(&self, other: &unsafe fn() -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(A, B, C) -> Ret
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: &unsafe extern "C" fn(A, B, C) -> Ret
) -> Option<Ordering>
sourceimpl<'_, '_, A, B> PartialOrd<&'_ B> for &'_ A where
A: PartialOrd<B> + ?Sized,
B: ?Sized,
impl<'_, '_, A, B> PartialOrd<&'_ B> for &'_ A where
A: PartialOrd<B> + ?Sized,
B: ?Sized,
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
sourceimpl<T, const N: usize> PartialOrd<[T; N]> for [T; N] where
T: PartialOrd<T>,
impl<T, const N: usize> PartialOrd<[T; N]> for [T; N] where
T: PartialOrd<T>,
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
sourceimpl<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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J> + ?Sized,
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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J> + ?Sized,
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
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
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
sourceimpl<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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G> + ?Sized,
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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G> + ?Sized,
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
fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool
1.4.0 · sourceimpl<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
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: &fn(A, B, C, D, E, F, G, H) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialOrd<fn(A, B, C, D) -> Ret> for fn(A, B, C, D) -> Ret
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: &fn(A, B, C, D) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>
sourceimpl<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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H> + ?Sized,
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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H> + ?Sized,
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
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
fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
sourceimpl<'_, '_, A, B> PartialOrd<&'_ mut B> for &'_ mut A where
A: PartialOrd<B> + ?Sized,
B: ?Sized,
impl<'_, '_, A, B> PartialOrd<&'_ mut B> for &'_ mut A where
A: PartialOrd<B> + ?Sized,
B: ?Sized,
sourceimpl<A> PartialOrd<(A,)> for (A,) where
A: PartialOrd<A> + PartialEq<A> + ?Sized,
impl<A> PartialOrd<(A,)> for (A,) where
A: PartialOrd<A> + PartialEq<A> + ?Sized,
sourceimpl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E> + ?Sized,
impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E> + ?Sized,
1.4.0 · sourceimpl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret
impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret
fn partial_cmp(&self, other: &fn() -> Ret) -> Option<Ordering>
sourceimpl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C> + ?Sized,
impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C> + ?Sized,
sourceimpl PartialOrd<usize> for usize
impl PartialOrd<usize> for usize
1.4.0 · sourceimpl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
impl<Ret, A> PartialOrd<unsafe fn(A) -> Ret> for unsafe fn(A) -> Ret
fn partial_cmp(&self, other: &unsafe fn(A) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E) -> Ret
) -> Option<Ordering>
sourceimpl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F> + ?Sized,
impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F> + ?Sized,
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(A, B) -> Ret
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: &unsafe extern "C" fn(A, B) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C> PartialOrd<extern "C" fn(A, B, C) -> Ret> for extern "C" fn(A, B, C) -> Ret
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: &extern "C" fn(A, B, C) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<f64> for f64
impl PartialOrd<f64> for f64
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialOrd<extern "C" fn(A, B, C, D) -> Ret> for extern "C" fn(A, B, C, D) -> Ret
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: &extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<u16> for u16
impl PartialOrd<u16> for u16
1.4.0 · sourceimpl<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
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: &extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<i32> for i32
impl PartialOrd<i32> for i32
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B> PartialOrd<unsafe extern "C" fn(A, B, ...) -> Ret> for unsafe extern "C" fn(A, B, ...) -> Ret
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: &unsafe extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret
impl<Ret, A, B> PartialOrd<unsafe fn(A, B) -> Ret> for unsafe fn(A, B) -> Ret
fn partial_cmp(&self, other: &unsafe fn(A, B) -> Ret) -> Option<Ordering>
sourceimpl PartialOrd<u8> for u8
impl PartialOrd<u8> for u8
1.4.0 · sourceimpl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>
sourceimpl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
impl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
sourceimpl PartialOrd<!> for !
impl PartialOrd<!> for !
fn partial_cmp(&self, &!) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>
sourceimpl<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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I> + ?Sized,
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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I> + ?Sized,
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
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
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
sourceimpl<Dyn> PartialOrd<DynMetadata<Dyn>> for DynMetadata<Dyn> where
Dyn: ?Sized,
impl<Dyn> PartialOrd<DynMetadata<Dyn>> for DynMetadata<Dyn> where
Dyn: ?Sized,
fn partial_cmp(&self, other: &DynMetadata<Dyn>) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialOrd<unsafe fn(A, B, C, D) -> Ret> for unsafe fn(A, B, C, D) -> Ret
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: &unsafe fn(A, B, C, D) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
1.25.0 · sourceimpl<T> PartialOrd<NonNull<T>> for NonNull<T> where
T: ?Sized,
impl<T> PartialOrd<NonNull<T>> for NonNull<T> where
T: ?Sized,
fn partial_cmp(&self, other: &NonNull<T>) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E> PartialOrd<fn(A, B, C, D, E) -> Ret> for fn(A, B, C, D, E) -> Ret
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: &fn(A, B, C, D, E) -> Ret) -> Option<Ordering>
sourceimpl PartialOrd<u128> for u128
impl PartialOrd<u128> for u128
1.4.0 · sourceimpl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret
impl<Ret, A, B, C> PartialOrd<fn(A, B, C) -> Ret> for fn(A, B, C) -> Ret
fn partial_cmp(&self, other: &fn(A, B, C) -> Ret) -> Option<Ordering>
sourceimpl<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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K> + ?Sized,
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: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K> + ?Sized,
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
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
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
1.4.0 · sourceimpl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret
impl<Ret, A> PartialOrd<extern "C" fn(A, ...) -> Ret> for extern "C" fn(A, ...) -> Ret
fn partial_cmp(&self, other: &extern "C" fn(A, ...) -> Ret) -> Option<Ordering>
sourceimpl PartialOrd<f32> for f32
impl PartialOrd<f32> for f32
1.4.0 · sourceimpl<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
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: &unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C> PartialOrd<unsafe extern "C" fn(A, B, C, ...) -> Ret> for unsafe extern "C" fn(A, B, C, ...) -> Ret
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: &unsafe extern "C" fn(A, B, C, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
impl<Ret, A, B> PartialOrd<extern "C" fn(A, B, ...) -> Ret> for extern "C" fn(A, B, ...) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret
impl<Ret, A> PartialOrd<fn(A) -> Ret> for fn(A) -> Ret
fn partial_cmp(&self, other: &fn(A) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<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
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: &fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret
) -> Option<Ordering>
sourceimpl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D> + ?Sized,
impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D> + ?Sized,
sourceimpl PartialOrd<i128> for i128
impl PartialOrd<i128> for i128
sourceimpl PartialOrd<bool> for bool
impl PartialOrd<bool> for bool
fn partial_cmp(&self, other: &bool) -> Option<Ordering>
sourceimpl PartialOrd<u32> for u32
impl PartialOrd<u32> for u32
sourceimpl PartialOrd<String> for String
impl PartialOrd<String> for String
fn partial_cmp(&self, other: &String) -> Option<Ordering>
sourceimpl<T, A> PartialOrd<Vec<T, A>> for Vec<T, A> where
T: PartialOrd<T>,
A: Allocator,
impl<T, A> PartialOrd<Vec<T, A>> for Vec<T, A> where
T: PartialOrd<T>,
A: Allocator,
Implements comparison of vectors, lexicographically.
fn partial_cmp(&self, other: &Vec<T, A>) -> Option<Ordering>
sourceimpl<T> PartialOrd<Rc<T>> for Rc<T> where
T: PartialOrd<T> + ?Sized,
impl<T> PartialOrd<Rc<T>> for Rc<T> where
T: PartialOrd<T> + ?Sized,
sourcefn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>
fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering>
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)));
sourcefn lt(&self, other: &Rc<T>) -> bool
fn lt(&self, other: &Rc<T>) -> bool
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));
sourcefn le(&self, other: &Rc<T>) -> bool
fn le(&self, other: &Rc<T>) -> bool
‘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));
sourceimpl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &LinkedList<T>) -> Option<Ordering>
sourceimpl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
T: PartialOrd<T> + ?Sized,
A: Allocator,
impl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
T: PartialOrd<T> + ?Sized,
A: Allocator,
sourceimpl PartialOrd<LibInBundleI> for usize
impl PartialOrd<LibInBundleI> for usize
fn partial_cmp(&self, other: &LibInBundleI) -> Option<Ordering>
sourceimpl PartialOrd<Notch> for usize
impl PartialOrd<Notch> for usize
fn partial_cmp(&self, other: &Notch) -> Option<Ordering>
sourceimpl PartialOrd<InHand> for usize
impl PartialOrd<InHand> for usize
fn partial_cmp(&self, other: &InHand) -> Option<Ordering>
sourceimpl PartialOrd<SvgId> for usize
impl PartialOrd<SvgId> for usize
fn partial_cmp(&self, other: &SvgId) -> Option<Ordering>
sourceimpl PartialOrd<DescId> for usize
impl PartialOrd<DescId> for usize
fn partial_cmp(&self, other: &DescId) -> Option<Ordering>
sourceimpl PartialOrd<FaceId> for usize
impl PartialOrd<FaceId> for usize
fn partial_cmp(&self, other: &FaceId) -> Option<Ordering>
sourceimpl<const CAP: usize> PartialOrd<ArrayString<CAP>> for str
impl<const CAP: usize> PartialOrd<ArrayString<CAP>> for str
fn partial_cmp(&self, rhs: &ArrayString<CAP>) -> Option<Ordering>
fn lt(&self, rhs: &ArrayString<CAP>) -> bool
fn le(&self, rhs: &ArrayString<CAP>) -> bool
fn gt(&self, rhs: &ArrayString<CAP>) -> bool
fn ge(&self, rhs: &ArrayString<CAP>) -> bool
sourceimpl PartialOrd<CommaSeparator> for CommaSeparator
impl PartialOrd<CommaSeparator> for CommaSeparator
fn partial_cmp(&self, other: &CommaSeparator) -> Option<Ordering>
sourceimpl PartialOrd<SpaceSeparator> for SpaceSeparator
impl PartialOrd<SpaceSeparator> for SpaceSeparator
fn partial_cmp(&self, other: &SpaceSeparator) -> Option<Ordering>
sourceimpl<Sep, T> PartialOrd<StringWithSeparator<Sep, T>> for StringWithSeparator<Sep, T> where
Sep: PartialOrd<Sep>,
T: PartialOrd<T>,
impl<Sep, T> PartialOrd<StringWithSeparator<Sep, T>> for StringWithSeparator<Sep, T> where
Sep: PartialOrd<Sep>,
T: PartialOrd<T>,
fn partial_cmp(&self, other: &StringWithSeparator<Sep, T>) -> Option<Ordering>
impl<A> PartialOrd<SmallVec<A>> for SmallVec<A> where
A: Array,
<A as Array>::Item: PartialOrd<<A as Array>::Item>,
impl<A> PartialOrd<SmallVec<A>> for SmallVec<A> where
A: Array,
<A as Array>::Item: PartialOrd<<A as Array>::Item>,
fn partial_cmp(&self, other: &SmallVec<A>) -> Option<Ordering>
impl<EntryData> PartialOrd<VecList<EntryData>> for VecList<EntryData> where
EntryData: PartialOrd<EntryData>,
impl<EntryData> PartialOrd<VecList<EntryData>> for VecList<EntryData> where
EntryData: PartialOrd<EntryData>,
fn partial_cmp(&self, other: &VecList<EntryData>) -> Option<Ordering>
sourceimpl PartialOrd<SteadyTime> for SteadyTime
impl PartialOrd<SteadyTime> for SteadyTime
fn partial_cmp(&self, other: &SteadyTime) -> Option<Ordering>
sourceimpl PartialOrd<Tm> for Tm
impl PartialOrd<Tm> for Tm
fn partial_cmp(&self, other: &Tm) -> Option<Ordering>
sourceimpl PartialOrd<Timespec> for Timespec
impl PartialOrd<Timespec> for Timespec
fn partial_cmp(&self, other: &Timespec) -> Option<Ordering>
impl PartialOrd<UncasedStr> for str
impl PartialOrd<UncasedStr> for str
fn partial_cmp(&self, other: &UncasedStr) -> Option<Ordering>
impl PartialOrd<UncasedStr> for UncasedStr
impl PartialOrd<UncasedStr> for UncasedStr
fn partial_cmp(&self, other: &UncasedStr) -> Option<Ordering>
impl PartialOrd<str> for UncasedStr
impl PartialOrd<str> for UncasedStr
fn partial_cmp(&self, other: &str) -> Option<Ordering>
impl PartialOrd<Char> for char
impl PartialOrd<Char> for char
fn partial_cmp(&self, other: &Char) -> Option<Ordering>
impl PartialOrd<ClassUnicodeRange> for ClassUnicodeRange
impl PartialOrd<ClassUnicodeRange> for ClassUnicodeRange
fn partial_cmp(&self, other: &ClassUnicodeRange) -> Option<Ordering>
impl PartialOrd<Span> for Span
impl PartialOrd<Span> for Span
fn partial_cmp(&self, other: &Span) -> Option<Ordering>
impl PartialOrd<ClassBytesRange> for ClassBytesRange
impl PartialOrd<ClassBytesRange> for ClassBytesRange
fn partial_cmp(&self, other: &ClassBytesRange) -> Option<Ordering>
impl PartialOrd<Utf8Range> for Utf8Range
impl PartialOrd<Utf8Range> for Utf8Range
fn partial_cmp(&self, other: &Utf8Range) -> Option<Ordering>
impl PartialOrd<Utf8Sequence> for Utf8Sequence
impl PartialOrd<Utf8Sequence> for Utf8Sequence
fn partial_cmp(&self, other: &Utf8Sequence) -> Option<Ordering>
impl PartialOrd<Position> for Position
impl PartialOrd<Position> for Position
fn partial_cmp(&self, other: &Position) -> Option<Ordering>
impl PartialOrd<Literal> for Literal
impl PartialOrd<Literal> for Literal
fn partial_cmp(&self, other: &Literal) -> Option<Ordering>
impl PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, rhs: &Instant) -> Option<Ordering>
impl PartialOrd<Time> for Time
impl PartialOrd<Time> for Time
fn partial_cmp(&self, other: &Time) -> Option<Ordering>
impl PartialOrd<OffsetDateTime> for OffsetDateTime
impl PartialOrd<OffsetDateTime> for OffsetDateTime
fn partial_cmp(&self, rhs: &OffsetDateTime) -> Option<Ordering>
impl PartialOrd<Duration> for Duration
impl PartialOrd<Duration> for Duration
fn partial_cmp(&self, other: &Duration) -> Option<Ordering>
impl PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, other: &Instant) -> Option<Ordering>
impl PartialOrd<Date> for Date
impl PartialOrd<Date> for Date
fn partial_cmp(&self, other: &Date) -> Option<Ordering>
impl PartialOrd<PrimitiveDateTime> for PrimitiveDateTime
impl PartialOrd<PrimitiveDateTime> for PrimitiveDateTime
fn partial_cmp(&self, other: &PrimitiveDateTime) -> Option<Ordering>
impl PartialOrd<SystemTime> for OffsetDateTime
impl PartialOrd<SystemTime> for OffsetDateTime
fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering>
impl PartialOrd<Duration> for Duration
impl PartialOrd<Duration> for Duration
fn partial_cmp(&self, rhs: &Duration) -> Option<Ordering>
impl PartialOrd<UtcOffset> for UtcOffset
impl PartialOrd<UtcOffset> for UtcOffset
fn partial_cmp(&self, other: &UtcOffset) -> Option<Ordering>
impl PartialOrd<RecursiveMode> for RecursiveMode
impl PartialOrd<RecursiveMode> for RecursiveMode
fn partial_cmp(&self, other: &RecursiveMode) -> Option<Ordering>
impl PartialOrd<Op> for Op
impl PartialOrd<Op> for Op
fn partial_cmp(&self, other: &Op) -> Option<Ordering>
impl PartialOrd<FileTime> for FileTime
impl PartialOrd<FileTime> for FileTime
fn partial_cmp(&self, other: &FileTime) -> Option<Ordering>
sourceimpl PartialOrd<Token> for Token
impl PartialOrd<Token> for Token
fn partial_cmp(&self, other: &Token) -> Option<Ordering>
sourceimpl PartialOrd<UnixReady> for UnixReady
impl PartialOrd<UnixReady> for UnixReady
fn partial_cmp(&self, other: &UnixReady) -> Option<Ordering>
sourceimpl PartialOrd<PollOpt> for PollOpt
impl PartialOrd<PollOpt> for PollOpt
fn partial_cmp(&self, other: &PollOpt) -> Option<Ordering>
sourceimpl PartialOrd<Ready> for Ready
impl PartialOrd<Ready> for Ready
fn partial_cmp(&self, other: &Ready) -> Option<Ordering>
impl PartialOrd<EventMask> for EventMask
impl PartialOrd<EventMask> for EventMask
fn partial_cmp(&self, other: &EventMask) -> Option<Ordering>
impl PartialOrd<WatchMask> for WatchMask
impl PartialOrd<WatchMask> for WatchMask
fn partial_cmp(&self, other: &WatchMask) -> Option<Ordering>
impl PartialOrd<DwLne> for DwLne
impl PartialOrd<DwLne> for DwLne
fn partial_cmp(&self, other: &DwLne) -> Option<Ordering>
impl<T> PartialOrd<DebugTypesOffset<T>> for DebugTypesOffset<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<DebugTypesOffset<T>> for DebugTypesOffset<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &DebugTypesOffset<T>) -> Option<Ordering>
impl<T> PartialOrd<UnitOffset<T>> for UnitOffset<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<UnitOffset<T>> for UnitOffset<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &UnitOffset<T>) -> Option<Ordering>
impl PartialOrd<DwVirtuality> for DwVirtuality
impl PartialOrd<DwVirtuality> for DwVirtuality
fn partial_cmp(&self, other: &DwVirtuality) -> Option<Ordering>
impl PartialOrd<DwChildren> for DwChildren
impl PartialOrd<DwChildren> for DwChildren
fn partial_cmp(&self, other: &DwChildren) -> Option<Ordering>
impl PartialOrd<DwAddr> for DwAddr
impl PartialOrd<DwAddr> for DwAddr
fn partial_cmp(&self, other: &DwAddr) -> Option<Ordering>
impl PartialOrd<DwAccess> for DwAccess
impl PartialOrd<DwAccess> for DwAccess
fn partial_cmp(&self, other: &DwAccess) -> Option<Ordering>
impl PartialOrd<Register> for Register
impl PartialOrd<Register> for Register
fn partial_cmp(&self, other: &Register) -> Option<Ordering>
impl PartialOrd<DwAt> for DwAt
impl PartialOrd<DwAt> for DwAt
fn partial_cmp(&self, other: &DwAt) -> Option<Ordering>
impl PartialOrd<ColumnType> for ColumnType
impl PartialOrd<ColumnType> for ColumnType
fn partial_cmp(&self, other: &ColumnType) -> Option<Ordering>
impl PartialOrd<DwDs> for DwDs
impl PartialOrd<DwDs> for DwDs
fn partial_cmp(&self, other: &DwDs) -> Option<Ordering>
impl PartialOrd<DwForm> for DwForm
impl PartialOrd<DwForm> for DwForm
fn partial_cmp(&self, other: &DwForm) -> Option<Ordering>
impl PartialOrd<DwCfa> for DwCfa
impl PartialOrd<DwCfa> for DwCfa
fn partial_cmp(&self, other: &DwCfa) -> Option<Ordering>
impl PartialOrd<DwLang> for DwLang
impl PartialOrd<DwLang> for DwLang
fn partial_cmp(&self, other: &DwLang) -> Option<Ordering>
impl PartialOrd<DwEnd> for DwEnd
impl PartialOrd<DwEnd> for DwEnd
fn partial_cmp(&self, other: &DwEnd) -> Option<Ordering>
impl<T> PartialOrd<UnitSectionOffset<T>> for UnitSectionOffset<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<UnitSectionOffset<T>> for UnitSectionOffset<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &UnitSectionOffset<T>) -> Option<Ordering>
impl PartialOrd<DwDsc> for DwDsc
impl PartialOrd<DwDsc> for DwDsc
fn partial_cmp(&self, other: &DwDsc) -> Option<Ordering>
impl PartialOrd<DwId> for DwId
impl PartialOrd<DwId> for DwId
fn partial_cmp(&self, other: &DwId) -> Option<Ordering>
impl PartialOrd<DwAte> for DwAte
impl PartialOrd<DwAte> for DwAte
fn partial_cmp(&self, other: &DwAte) -> Option<Ordering>
impl PartialOrd<DwRle> for DwRle
impl PartialOrd<DwRle> for DwRle
fn partial_cmp(&self, other: &DwRle) -> Option<Ordering>
impl PartialOrd<DwVis> for DwVis
impl PartialOrd<DwVis> for DwVis
fn partial_cmp(&self, other: &DwVis) -> Option<Ordering>
impl PartialOrd<DwSectV2> for DwSectV2
impl PartialOrd<DwSectV2> for DwSectV2
fn partial_cmp(&self, other: &DwSectV2) -> Option<Ordering>
impl PartialOrd<DwInl> for DwInl
impl PartialOrd<DwInl> for DwInl
fn partial_cmp(&self, other: &DwInl) -> Option<Ordering>
impl PartialOrd<DwTag> for DwTag
impl PartialOrd<DwTag> for DwTag
fn partial_cmp(&self, other: &DwTag) -> Option<Ordering>
impl PartialOrd<DwOrd> for DwOrd
impl PartialOrd<DwOrd> for DwOrd
fn partial_cmp(&self, other: &DwOrd) -> Option<Ordering>
impl PartialOrd<DwOp> for DwOp
impl PartialOrd<DwOp> for DwOp
fn partial_cmp(&self, other: &DwOp) -> Option<Ordering>
impl PartialOrd<DwIdx> for DwIdx
impl PartialOrd<DwIdx> for DwIdx
fn partial_cmp(&self, other: &DwIdx) -> Option<Ordering>
impl PartialOrd<DwLns> for DwLns
impl PartialOrd<DwLns> for DwLns
fn partial_cmp(&self, other: &DwLns) -> Option<Ordering>
impl PartialOrd<DwSect> for DwSect
impl PartialOrd<DwSect> for DwSect
fn partial_cmp(&self, other: &DwSect) -> Option<Ordering>
impl PartialOrd<DwLnct> for DwLnct
impl PartialOrd<DwLnct> for DwLnct
fn partial_cmp(&self, other: &DwLnct) -> Option<Ordering>
impl PartialOrd<SectionId> for SectionId
impl PartialOrd<SectionId> for SectionId
fn partial_cmp(&self, other: &SectionId) -> Option<Ordering>
impl PartialOrd<DwMacro> for DwMacro
impl PartialOrd<DwMacro> for DwMacro
fn partial_cmp(&self, other: &DwMacro) -> Option<Ordering>
impl PartialOrd<ArangeEntry> for ArangeEntry
impl PartialOrd<ArangeEntry> for ArangeEntry
fn partial_cmp(&self, other: &ArangeEntry) -> Option<Ordering>
impl PartialOrd<DwUt> for DwUt
impl PartialOrd<DwUt> for DwUt
fn partial_cmp(&self, other: &DwUt) -> Option<Ordering>
impl<T> PartialOrd<DebugInfoOffset<T>> for DebugInfoOffset<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<DebugInfoOffset<T>> for DebugInfoOffset<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &DebugInfoOffset<T>) -> Option<Ordering>
impl PartialOrd<DwEhPe> for DwEhPe
impl PartialOrd<DwEhPe> for DwEhPe
fn partial_cmp(&self, other: &DwEhPe) -> Option<Ordering>
impl PartialOrd<DwDefaulted> for DwDefaulted
impl PartialOrd<DwDefaulted> for DwDefaulted
fn partial_cmp(&self, other: &DwDefaulted) -> Option<Ordering>
impl PartialOrd<DwLle> for DwLle
impl PartialOrd<DwLle> for DwLle
fn partial_cmp(&self, other: &DwLle) -> Option<Ordering>
impl PartialOrd<DwCc> for DwCc
impl PartialOrd<DwCc> for DwCc
fn partial_cmp(&self, other: &DwCc) -> Option<Ordering>
impl<E> PartialOrd<U64Bytes<E>> for U64Bytes<E> where
E: PartialOrd<E> + Endian,
impl<E> PartialOrd<U64Bytes<E>> for U64Bytes<E> where
E: PartialOrd<E> + Endian,
fn partial_cmp(&self, other: &U64Bytes<E>) -> Option<Ordering>
impl<E> PartialOrd<I16Bytes<E>> for I16Bytes<E> where
E: PartialOrd<E> + Endian,
impl<E> PartialOrd<I16Bytes<E>> for I16Bytes<E> where
E: PartialOrd<E> + Endian,
fn partial_cmp(&self, other: &I16Bytes<E>) -> Option<Ordering>
impl<E> PartialOrd<I32Bytes<E>> for I32Bytes<E> where
E: PartialOrd<E> + Endian,
impl<E> PartialOrd<I32Bytes<E>> for I32Bytes<E> where
E: PartialOrd<E> + Endian,
fn partial_cmp(&self, other: &I32Bytes<E>) -> Option<Ordering>
impl<E> PartialOrd<U16Bytes<E>> for U16Bytes<E> where
E: PartialOrd<E> + Endian,
impl<E> PartialOrd<U16Bytes<E>> for U16Bytes<E> where
E: PartialOrd<E> + Endian,
fn partial_cmp(&self, other: &U16Bytes<E>) -> Option<Ordering>
impl<E> PartialOrd<U32Bytes<E>> for U32Bytes<E> where
E: PartialOrd<E> + Endian,
impl<E> PartialOrd<U32Bytes<E>> for U32Bytes<E> where
E: PartialOrd<E> + Endian,
fn partial_cmp(&self, other: &U32Bytes<E>) -> Option<Ordering>
impl<E> PartialOrd<I64Bytes<E>> for I64Bytes<E> where
E: PartialOrd<E> + Endian,
impl<E> PartialOrd<I64Bytes<E>> for I64Bytes<E> where
E: PartialOrd<E> + Endian,
fn partial_cmp(&self, other: &I64Bytes<E>) -> Option<Ordering>
impl PartialOrd<UnicodeVersion> for UnicodeVersion
impl PartialOrd<UnicodeVersion> for UnicodeVersion
fn partial_cmp(&self, other: &UnicodeVersion) -> Option<Ordering>
sourceimpl<'i> PartialOrd<Position<'i>> for Position<'i>
impl<'i> PartialOrd<Position<'i>> for Position<'i>
fn partial_cmp(&self, other: &Position<'i>) -> Option<Ordering>
impl PartialOrd<FileType> for FileType
impl PartialOrd<FileType> for FileType
fn partial_cmp(&self, other: &FileType) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BStr> for Vec<u8, Global>
impl<'a, 'b> PartialOrd<BStr> for Vec<u8, Global>
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BString> for BStr
impl<'a, 'b> PartialOrd<BString> for BStr
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl<'a, 'b> PartialOrd<&'a BStr> for Vec<u8, Global>
impl<'a, 'b> PartialOrd<&'a BStr> for Vec<u8, Global>
fn partial_cmp(&self, other: &&'a BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<String> for BString
impl<'a, 'b> PartialOrd<String> for BString
fn partial_cmp(&self, other: &String) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BString> for Vec<u8, Global>
impl<'a, 'b> PartialOrd<BString> for Vec<u8, Global>
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BStr> for &'a str
impl<'a, 'b> PartialOrd<BStr> for &'a str
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<[u8]> for BStr
impl<'a, 'b> PartialOrd<[u8]> for BStr
impl<'a, 'b> PartialOrd<str> for BString
impl<'a, 'b> PartialOrd<str> for BString
fn partial_cmp(&self, other: &str) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BString> for String
impl<'a, 'b> PartialOrd<BString> for String
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl<'a, 'b> PartialOrd<&'a BStr> for BString
impl<'a, 'b> PartialOrd<&'a BStr> for BString
fn partial_cmp(&self, other: &&'a BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BStr> for &'a [u8]
impl<'a, 'b> PartialOrd<BStr> for &'a [u8]
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<&'a [u8]> for BStr
impl<'a, 'b> PartialOrd<&'a [u8]> for BStr
impl<'a, 'b> PartialOrd<String> for &'a BStr
impl<'a, 'b> PartialOrd<String> for &'a BStr
fn partial_cmp(&self, other: &String) -> Option<Ordering>
impl<'a, 'b> PartialOrd<&'a str> for BString
impl<'a, 'b> PartialOrd<&'a str> for BString
fn partial_cmp(&self, other: &&'a str) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BString> for &'a str
impl<'a, 'b> PartialOrd<BString> for &'a str
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl<'a, 'b> PartialOrd<[u8]> for BString
impl<'a, 'b> PartialOrd<[u8]> for BString
impl<'a, 'b> PartialOrd<String> for BStr
impl<'a, 'b> PartialOrd<String> for BStr
fn partial_cmp(&self, other: &String) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BStr> for [u8]
impl<'a, 'b> PartialOrd<BStr> for [u8]
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<Vec<u8, Global>> for BStr
impl<'a, 'b> PartialOrd<Vec<u8, Global>> for BStr
impl<'a, 'b> PartialOrd<BString> for &'a [u8]
impl<'a, 'b> PartialOrd<BString> for &'a [u8]
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl<'a, 'b> PartialOrd<Vec<u8, Global>> for BString
impl<'a, 'b> PartialOrd<Vec<u8, Global>> for BString
impl<'a, 'b> PartialOrd<&'a str> for BStr
impl<'a, 'b> PartialOrd<&'a str> for BStr
fn partial_cmp(&self, other: &&'a str) -> Option<Ordering>
impl<'a, 'b> PartialOrd<Vec<u8, Global>> for &'a BStr
impl<'a, 'b> PartialOrd<Vec<u8, Global>> for &'a BStr
impl<'a, 'b> PartialOrd<BStr> for str
impl<'a, 'b> PartialOrd<BStr> for str
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<str> for BStr
impl<'a, 'b> PartialOrd<str> for BStr
fn partial_cmp(&self, other: &str) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BString> for str
impl<'a, 'b> PartialOrd<BString> for str
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl<'a, 'b> PartialOrd<&'a BStr> for String
impl<'a, 'b> PartialOrd<&'a BStr> for String
fn partial_cmp(&self, other: &&'a BStr) -> Option<Ordering>
impl PartialOrd<BStr> for BStr
impl PartialOrd<BStr> for BStr
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BStr> for String
impl<'a, 'b> PartialOrd<BStr> for String
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<&'a [u8]> for BString
impl<'a, 'b> PartialOrd<&'a [u8]> for BString
impl<'a, 'b> PartialOrd<BString> for &'a BStr
impl<'a, 'b> PartialOrd<BString> for &'a BStr
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BStr> for BString
impl<'a, 'b> PartialOrd<BStr> for BString
fn partial_cmp(&self, other: &BStr) -> Option<Ordering>
impl<'a, 'b> PartialOrd<BString> for [u8]
impl<'a, 'b> PartialOrd<BString> for [u8]
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
impl PartialOrd<BString> for BString
impl PartialOrd<BString> for BString
fn partial_cmp(&self, other: &BString) -> Option<Ordering>
sourceimpl PartialOrd<Algorithm> for Algorithm
impl PartialOrd<Algorithm> for Algorithm
fn partial_cmp(&self, other: &Algorithm) -> Option<Ordering>
sourceimpl<'a> PartialOrd<Ident<'a>> for Ident<'a>
impl<'a> PartialOrd<Ident<'a>> for Ident<'a>
fn partial_cmp(&self, other: &Ident<'a>) -> Option<Ordering>
sourceimpl<'a> PartialOrd<Value<'a>> for Value<'a>
impl<'a> PartialOrd<Value<'a>> for Value<'a>
fn partial_cmp(&self, other: &Value<'a>) -> Option<Ordering>
sourceimpl PartialOrd<Encoding> for Encoding
impl PartialOrd<Encoding> for Encoding
fn partial_cmp(&self, other: &Encoding) -> Option<Ordering>
sourceimpl<T> PartialOrd<Ascii<T>> for Ascii<T> where
T: AsRef<str>,
impl<T> PartialOrd<Ascii<T>> for Ascii<T> where
T: AsRef<str>,
fn partial_cmp(&self, other: &Ascii<T>) -> Option<Ordering>
sourceimpl<S> PartialOrd<Host<S>> for Host<S> where
S: PartialOrd<S>,
impl<S> PartialOrd<Host<S>> for Host<S> where
S: PartialOrd<S>,
fn partial_cmp(&self, other: &Host<S>) -> Option<Ordering>
impl PartialOrd<Level> for Level
impl PartialOrd<Level> for Level
fn partial_cmp(&self, other: &Level) -> Option<Ordering>
impl<'s, T> PartialOrd<SliceVec<'s, T>> for SliceVec<'s, T> where
T: PartialOrd<T>,
impl<'s, T> PartialOrd<SliceVec<'s, T>> for SliceVec<'s, T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &SliceVec<'s, T>) -> Option<Ordering>
impl<A> PartialOrd<TinyVec<A>> for TinyVec<A> where
A: Array,
<A as Array>::Item: PartialOrd<<A as Array>::Item>,
impl<A> PartialOrd<TinyVec<A>> for TinyVec<A> where
A: Array,
<A as Array>::Item: PartialOrd<<A as Array>::Item>,
fn partial_cmp(&self, other: &TinyVec<A>) -> Option<Ordering>
impl<A> PartialOrd<ArrayVec<A>> for ArrayVec<A> where
A: Array,
<A as Array>::Item: PartialOrd<<A as Array>::Item>,
impl<A> PartialOrd<ArrayVec<A>> for ArrayVec<A> where
A: Array,
<A as Array>::Item: PartialOrd<<A as Array>::Item>,
fn partial_cmp(&self, other: &ArrayVec<A>) -> Option<Ordering>
impl PartialOrd<Token> for Token
impl PartialOrd<Token> for Token
fn partial_cmp(&self, other: &Token) -> Option<Ordering>
impl PartialOrd<Interest> for Interest
impl PartialOrd<Interest> for Interest
fn partial_cmp(&self, other: &Interest) -> Option<Ordering>
impl PartialOrd<NormalForm> for NormalForm
impl PartialOrd<NormalForm> for NormalForm
fn partial_cmp(&self, other: &NormalForm) -> Option<Ordering>
fn partial_cmp(&self, other: &NormalForm) -> Option<Ordering>
Compares the logical preconditions.
a < b
if the normal form a
has less preconditions than b
.
impl PartialOrd<Delay> for Delay
impl PartialOrd<Delay> for Delay
fn partial_cmp(&self, other: &Delay) -> Option<Ordering>
sourceimpl<T> PartialOrd<Ratio<T>> for Ratio<T> where
T: Clone + Integer,
impl<T> PartialOrd<Ratio<T>> for Ratio<T> where
T: Clone + Integer,
fn partial_cmp(&self, other: &Ratio<T>) -> Option<Ordering>
sourceimpl PartialOrd<Sign> for Sign
impl PartialOrd<Sign> for Sign
fn partial_cmp(&self, other: &Sign) -> Option<Ordering>
sourceimpl PartialOrd<BigInt> for BigInt
impl PartialOrd<BigInt> for BigInt
fn partial_cmp(&self, other: &BigInt) -> Option<Ordering>
sourceimpl PartialOrd<BigUint> for BigUint
impl PartialOrd<BigUint> for BigUint
fn partial_cmp(&self, other: &BigUint) -> Option<Ordering>
impl PartialOrd<Transformations> for Transformations
impl PartialOrd<Transformations> for Transformations
fn partial_cmp(&self, other: &Transformations) -> Option<Ordering>
impl PartialOrd<MatchingType> for MatchingType
impl PartialOrd<MatchingType> for MatchingType
fn partial_cmp(&self, other: &MatchingType) -> Option<Ordering>
impl PartialOrd<Compression> for Compression
impl PartialOrd<Compression> for Compression
fn partial_cmp(&self, other: &Compression) -> Option<Ordering>
impl PartialOrd<Attribute> for Attribute
impl PartialOrd<Attribute> for Attribute
fn partial_cmp(&self, other: &Attribute) -> Option<Ordering>
impl<V> PartialOrd<VecMap<V>> for VecMap<V> where
V: PartialOrd<V>,
impl<V> PartialOrd<VecMap<V>> for VecMap<V> where
V: PartialOrd<V>,
fn partial_cmp(&self, other: &VecMap<V>) -> Option<Ordering>
sourceimpl PartialOrd<Version> for Version
impl PartialOrd<Version> for Version
fn partial_cmp(&self, other: &Version) -> Option<Ordering>
sourceimpl<'a> PartialOrd<HeaderValue> for &'a str
impl<'a> PartialOrd<HeaderValue> for &'a str
fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>
sourceimpl PartialOrd<String> for Authority
impl PartialOrd<String> for Authority
fn partial_cmp(&self, other: &String) -> Option<Ordering>
sourceimpl PartialOrd<HeaderValue> for str
impl PartialOrd<HeaderValue> for str
fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>
sourceimpl PartialOrd<StatusCode> for StatusCode
impl PartialOrd<StatusCode> for StatusCode
fn partial_cmp(&self, other: &StatusCode) -> Option<Ordering>
sourceimpl PartialOrd<Authority> for Authority
impl PartialOrd<Authority> for Authority
Case-insensitive ordering
Examples
let authority: Authority = "DEF.com".parse().unwrap();
assert!(authority < "ghi.com");
assert!(authority > "abc.com");
fn partial_cmp(&self, other: &Authority) -> Option<Ordering>
sourceimpl<'a> PartialOrd<HeaderValue> for &'a HeaderValue
impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue
fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>
sourceimpl PartialOrd<[u8]> for HeaderValue
impl PartialOrd<[u8]> for HeaderValue
sourceimpl PartialOrd<String> for HeaderValue
impl PartialOrd<String> for HeaderValue
fn partial_cmp(&self, other: &String) -> Option<Ordering>
sourceimpl PartialOrd<PathAndQuery> for PathAndQuery
impl PartialOrd<PathAndQuery> for PathAndQuery
fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>
sourceimpl PartialOrd<HeaderValue> for HeaderValue
impl PartialOrd<HeaderValue> for HeaderValue
fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>
sourceimpl PartialOrd<Authority> for str
impl PartialOrd<Authority> for str
fn partial_cmp(&self, other: &Authority) -> Option<Ordering>
sourceimpl PartialOrd<str> for HeaderValue
impl PartialOrd<str> for HeaderValue
fn partial_cmp(&self, other: &str) -> Option<Ordering>
sourceimpl PartialOrd<Authority> for String
impl PartialOrd<Authority> for String
fn partial_cmp(&self, other: &Authority) -> Option<Ordering>
sourceimpl PartialOrd<HeaderValue> for String
impl PartialOrd<HeaderValue> for String
fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>
sourceimpl PartialOrd<HeaderValue> for [u8]
impl PartialOrd<HeaderValue> for [u8]
fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>
sourceimpl PartialOrd<PathAndQuery> for str
impl PartialOrd<PathAndQuery> for str
fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>
sourceimpl<'a, T> PartialOrd<&'a T> for HeaderValue where
T: ?Sized,
HeaderValue: PartialOrd<T>,
impl<'a, T> PartialOrd<&'a T> for HeaderValue where
T: ?Sized,
HeaderValue: PartialOrd<T>,
fn partial_cmp(&self, other: &&'a T) -> Option<Ordering>
sourceimpl PartialOrd<PathAndQuery> for String
impl PartialOrd<PathAndQuery> for String
fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>
sourceimpl<'a> PartialOrd<Authority> for &'a str
impl<'a> PartialOrd<Authority> for &'a str
fn partial_cmp(&self, other: &Authority) -> Option<Ordering>
sourceimpl PartialOrd<str> for PathAndQuery
impl PartialOrd<str> for PathAndQuery
fn partial_cmp(&self, other: &str) -> Option<Ordering>
sourceimpl PartialOrd<String> for PathAndQuery
impl PartialOrd<String> for PathAndQuery
fn partial_cmp(&self, other: &String) -> Option<Ordering>
sourceimpl<'a> PartialOrd<PathAndQuery> for &'a str
impl<'a> PartialOrd<PathAndQuery> for &'a str
fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>
sourceimpl<'a> PartialOrd<&'a str> for Authority
impl<'a> PartialOrd<&'a str> for Authority
fn partial_cmp(&self, other: &&'a str) -> Option<Ordering>
sourceimpl PartialOrd<Version> for Version
impl PartialOrd<Version> for Version
fn partial_cmp(&self, other: &Version) -> Option<Ordering>
sourceimpl<'a> PartialOrd<&'a str> for PathAndQuery
impl<'a> PartialOrd<&'a str> for PathAndQuery
fn partial_cmp(&self, other: &&'a str) -> Option<Ordering>
sourceimpl PartialOrd<str> for Authority
impl PartialOrd<str> for Authority
fn partial_cmp(&self, other: &str) -> Option<Ordering>
impl<'_> PartialOrd<Bytes> for &'_ [u8]
impl<'_> PartialOrd<Bytes> for &'_ [u8]
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
impl PartialOrd<BytesMut> for str
impl PartialOrd<BytesMut> for str
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
impl PartialOrd<String> for BytesMut
impl PartialOrd<String> for BytesMut
fn partial_cmp(&self, other: &String) -> Option<Ordering>
impl PartialOrd<str> for Bytes
impl PartialOrd<str> for Bytes
fn partial_cmp(&self, other: &str) -> Option<Ordering>
impl<'a, T> PartialOrd<&'a T> for Bytes where
T: ?Sized,
Bytes: PartialOrd<T>,
impl<'a, T> PartialOrd<&'a T> for Bytes where
T: ?Sized,
Bytes: PartialOrd<T>,
fn partial_cmp(&self, other: &&'a T) -> Option<Ordering>
impl PartialOrd<Bytes> for str
impl PartialOrd<Bytes> for str
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
impl PartialOrd<Bytes> for Vec<u8, Global>
impl PartialOrd<Bytes> for Vec<u8, Global>
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
impl PartialOrd<BytesMut> for Vec<u8, Global>
impl PartialOrd<BytesMut> for Vec<u8, Global>
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
impl PartialOrd<BytesMut> for String
impl PartialOrd<BytesMut> for String
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
impl PartialOrd<Vec<u8, Global>> for BytesMut
impl PartialOrd<Vec<u8, Global>> for BytesMut
impl<'_> PartialOrd<Bytes> for &'_ str
impl<'_> PartialOrd<Bytes> for &'_ str
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
impl PartialOrd<Bytes> for String
impl PartialOrd<Bytes> for String
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
impl<'a, T> PartialOrd<&'a T> for BytesMut where
T: ?Sized,
BytesMut: PartialOrd<T>,
impl<'a, T> PartialOrd<&'a T> for BytesMut where
T: ?Sized,
BytesMut: PartialOrd<T>,
fn partial_cmp(&self, other: &&'a T) -> Option<Ordering>
impl PartialOrd<BytesMut> for BytesMut
impl PartialOrd<BytesMut> for BytesMut
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
impl PartialOrd<[u8]> for Bytes
impl PartialOrd<[u8]> for Bytes
impl PartialOrd<[u8]> for BytesMut
impl PartialOrd<[u8]> for BytesMut
impl PartialOrd<BytesMut> for [u8]
impl PartialOrd<BytesMut> for [u8]
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
impl PartialOrd<String> for Bytes
impl PartialOrd<String> for Bytes
fn partial_cmp(&self, other: &String) -> Option<Ordering>
impl<'_> PartialOrd<BytesMut> for &'_ [u8]
impl<'_> PartialOrd<BytesMut> for &'_ [u8]
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
impl PartialOrd<str> for BytesMut
impl PartialOrd<str> for BytesMut
fn partial_cmp(&self, other: &str) -> Option<Ordering>
impl PartialOrd<Vec<u8, Global>> for Bytes
impl PartialOrd<Vec<u8, Global>> for Bytes
impl PartialOrd<Bytes> for [u8]
impl PartialOrd<Bytes> for [u8]
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
impl PartialOrd<Bytes> for Bytes
impl PartialOrd<Bytes> for Bytes
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
impl<'_> PartialOrd<BytesMut> for &'_ str
impl<'_> PartialOrd<BytesMut> for &'_ str
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
impl<T> PartialOrd<AllowStdIo<T>> for AllowStdIo<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<AllowStdIo<T>> for AllowStdIo<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &AllowStdIo<T>) -> Option<Ordering>
impl PartialOrd<Ready> for Ready
impl PartialOrd<Ready> for Ready
fn partial_cmp(&self, other: &Ready) -> Option<Ordering>
impl PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, other: &Instant) -> Option<Ordering>
impl PartialOrd<BytesCodec> for BytesCodec
impl PartialOrd<BytesCodec> for BytesCodec
fn partial_cmp(&self, other: &BytesCodec) -> Option<Ordering>
impl PartialOrd<AnyDelimiterCodec> for AnyDelimiterCodec
impl PartialOrd<AnyDelimiterCodec> for AnyDelimiterCodec
fn partial_cmp(&self, other: &AnyDelimiterCodec) -> Option<Ordering>
impl PartialOrd<LinesCodec> for LinesCodec
impl PartialOrd<LinesCodec> for LinesCodec
fn partial_cmp(&self, other: &LinesCodec) -> Option<Ordering>
sourceimpl PartialOrd<LevelFilter> for LevelFilter
impl PartialOrd<LevelFilter> for LevelFilter
fn partial_cmp(&self, other: &LevelFilter) -> Option<Ordering>
fn lt(&self, other: &LevelFilter) -> bool
fn le(&self, other: &LevelFilter) -> bool
fn gt(&self, other: &LevelFilter) -> bool
fn ge(&self, other: &LevelFilter) -> bool
sourceimpl PartialOrd<Level> for LevelFilter
impl PartialOrd<Level> for LevelFilter
sourceimpl PartialOrd<Level> for Level
impl PartialOrd<Level> for Level
sourceimpl PartialOrd<LevelFilter> for Level
impl PartialOrd<LevelFilter> for Level
fn partial_cmp(&self, other: &LevelFilter) -> Option<Ordering>
fn lt(&self, other: &LevelFilter) -> bool
fn le(&self, other: &LevelFilter) -> bool
fn gt(&self, other: &LevelFilter) -> bool
fn ge(&self, other: &LevelFilter) -> bool
impl PartialOrd<AnyDelimiterCodec> for AnyDelimiterCodec
impl PartialOrd<AnyDelimiterCodec> for AnyDelimiterCodec
fn partial_cmp(&self, other: &AnyDelimiterCodec) -> Option<Ordering>
impl PartialOrd<LinesCodec> for LinesCodec
impl PartialOrd<LinesCodec> for LinesCodec
fn partial_cmp(&self, other: &LinesCodec) -> Option<Ordering>
impl PartialOrd<BytesCodec> for BytesCodec
impl PartialOrd<BytesCodec> for BytesCodec
fn partial_cmp(&self, other: &BytesCodec) -> Option<Ordering>
sourceimpl PartialOrd<BigNum> for BigNumRef
impl PartialOrd<BigNum> for BigNumRef
fn partial_cmp(&self, oth: &BigNum) -> Option<Ordering>
sourceimpl<'a> PartialOrd<&'a Asn1TimeRef> for Asn1Time
impl<'a> PartialOrd<&'a Asn1TimeRef> for Asn1Time
fn partial_cmp(&self, other: &&'a Asn1TimeRef) -> Option<Ordering>
sourceimpl PartialOrd<Asn1Time> for Asn1Time
impl PartialOrd<Asn1Time> for Asn1Time
fn partial_cmp(&self, other: &Asn1Time) -> Option<Ordering>
sourceimpl PartialOrd<BigNumRef> for BigNum
impl PartialOrd<BigNumRef> for BigNum
fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering>
sourceimpl PartialOrd<Pkcs7Flags> for Pkcs7Flags
impl PartialOrd<Pkcs7Flags> for Pkcs7Flags
fn partial_cmp(&self, other: &Pkcs7Flags) -> Option<Ordering>
sourceimpl PartialOrd<X509VerifyFlags> for X509VerifyFlags
impl PartialOrd<X509VerifyFlags> for X509VerifyFlags
fn partial_cmp(&self, other: &X509VerifyFlags) -> Option<Ordering>
sourceimpl PartialOrd<X509CheckFlags> for X509CheckFlags
impl PartialOrd<X509CheckFlags> for X509CheckFlags
fn partial_cmp(&self, other: &X509CheckFlags) -> Option<Ordering>
sourceimpl PartialOrd<BigNum> for BigNum
impl PartialOrd<BigNum> for BigNum
fn partial_cmp(&self, oth: &BigNum) -> Option<Ordering>
sourceimpl PartialOrd<ShutdownState> for ShutdownState
impl PartialOrd<ShutdownState> for ShutdownState
fn partial_cmp(&self, other: &ShutdownState) -> Option<Ordering>
sourceimpl PartialOrd<BigNumRef> for BigNumRef
impl PartialOrd<BigNumRef> for BigNumRef
fn partial_cmp(&self, oth: &BigNumRef) -> Option<Ordering>
sourceimpl PartialOrd<Asn1TimeRef> for Asn1Time
impl PartialOrd<Asn1TimeRef> for Asn1Time
fn partial_cmp(&self, other: &Asn1TimeRef) -> Option<Ordering>
sourceimpl PartialOrd<OcspFlag> for OcspFlag
impl PartialOrd<OcspFlag> for OcspFlag
fn partial_cmp(&self, other: &OcspFlag) -> Option<Ordering>
sourceimpl PartialOrd<ExtensionContext> for ExtensionContext
impl PartialOrd<ExtensionContext> for ExtensionContext
fn partial_cmp(&self, other: &ExtensionContext) -> Option<Ordering>
sourceimpl PartialOrd<SslOptions> for SslOptions
impl PartialOrd<SslOptions> for SslOptions
fn partial_cmp(&self, other: &SslOptions) -> Option<Ordering>
sourceimpl PartialOrd<SslSessionCacheMode> for SslSessionCacheMode
impl PartialOrd<SslSessionCacheMode> for SslSessionCacheMode
fn partial_cmp(&self, other: &SslSessionCacheMode) -> Option<Ordering>
sourceimpl PartialOrd<Asn1Time> for Asn1TimeRef
impl PartialOrd<Asn1Time> for Asn1TimeRef
fn partial_cmp(&self, other: &Asn1Time) -> Option<Ordering>
sourceimpl PartialOrd<SslMode> for SslMode
impl PartialOrd<SslMode> for SslMode
fn partial_cmp(&self, other: &SslMode) -> Option<Ordering>
sourceimpl PartialOrd<Asn1TimeRef> for Asn1TimeRef
impl PartialOrd<Asn1TimeRef> for Asn1TimeRef
fn partial_cmp(&self, other: &Asn1TimeRef) -> Option<Ordering>
sourceimpl<'a> PartialOrd<Asn1Time> for &'a Asn1TimeRef
impl<'a> PartialOrd<Asn1Time> for &'a Asn1TimeRef
fn partial_cmp(&self, other: &Asn1Time) -> Option<Ordering>
sourceimpl PartialOrd<SslVerifyMode> for SslVerifyMode
impl PartialOrd<SslVerifyMode> for SslVerifyMode
fn partial_cmp(&self, other: &SslVerifyMode) -> Option<Ordering>
sourceimpl PartialOrd<CMSOptions> for CMSOptions
impl PartialOrd<CMSOptions> for CMSOptions
fn partial_cmp(&self, other: &CMSOptions) -> Option<Ordering>
sourceimpl PartialOrd<Mime> for Mime
impl PartialOrd<Mime> for Mime
fn partial_cmp(&self, other: &Mime) -> Option<Ordering>
sourceimpl<'a> PartialOrd<Name<'a>> for Name<'a>
impl<'a> PartialOrd<Name<'a>> for Name<'a>
fn partial_cmp(&self, other: &Name<'a>) -> Option<Ordering>
sourceimpl PartialOrd<IpSubnets> for IpSubnets
impl PartialOrd<IpSubnets> for IpSubnets
fn partial_cmp(&self, other: &IpSubnets) -> Option<Ordering>
sourceimpl PartialOrd<Ipv6AddrRange> for Ipv6AddrRange
impl PartialOrd<Ipv6AddrRange> for Ipv6AddrRange
fn partial_cmp(&self, other: &Ipv6AddrRange) -> Option<Ordering>
sourceimpl PartialOrd<Ipv4AddrRange> for Ipv4AddrRange
impl PartialOrd<Ipv4AddrRange> for Ipv4AddrRange
fn partial_cmp(&self, other: &Ipv4AddrRange) -> Option<Ordering>
sourceimpl PartialOrd<Ipv4Net> for Ipv4Net
impl PartialOrd<Ipv4Net> for Ipv4Net
fn partial_cmp(&self, other: &Ipv4Net) -> Option<Ordering>
sourceimpl PartialOrd<IpAddrRange> for IpAddrRange
impl PartialOrd<IpAddrRange> for IpAddrRange
fn partial_cmp(&self, other: &IpAddrRange) -> Option<Ordering>
sourceimpl PartialOrd<Ipv6Net> for Ipv6Net
impl PartialOrd<Ipv6Net> for Ipv6Net
fn partial_cmp(&self, other: &Ipv6Net) -> Option<Ordering>
sourceimpl PartialOrd<Ipv4Subnets> for Ipv4Subnets
impl PartialOrd<Ipv4Subnets> for Ipv4Subnets
fn partial_cmp(&self, other: &Ipv4Subnets) -> Option<Ordering>
sourceimpl PartialOrd<IpNet> for IpNet
impl PartialOrd<IpNet> for IpNet
fn partial_cmp(&self, other: &IpNet) -> Option<Ordering>
sourceimpl PartialOrd<Ipv6Subnets> for Ipv6Subnets
impl PartialOrd<Ipv6Subnets> for Ipv6Subnets
fn partial_cmp(&self, other: &Ipv6Subnets) -> Option<Ordering>
Implementors
impl PartialOrd<Kind> for Kind
impl PartialOrd<AccountScope> for AccountScope
impl PartialOrd<LinkKind> for LinkKind
impl PartialOrd<OccultationKindGeneral<(OccDisplacement, ZCoord)>> for OccultationKindGeneral<(OccDisplacement, ZCoord)>
impl PartialOrd<PieceMoveable> for PieceMoveable
impl PartialOrd<StaticUser> for StaticUser
impl PartialOrd<TablePermission> for TablePermission
impl PartialOrd<Level> for otter_api_tests::flexi_logger::Level
impl PartialOrd<Level> for otter_api_tests::flexi_logger::LevelFilter
impl PartialOrd<LevelFilter> for otter_api_tests::flexi_logger::Level
impl PartialOrd<LevelFilter> for otter_api_tests::flexi_logger::LevelFilter
impl PartialOrd<Which> for Which
impl PartialOrd<PosixFadviseAdvice> for PosixFadviseAdvice
impl PartialOrd<AioFsyncMode> for AioFsyncMode
impl PartialOrd<LioMode> for LioMode
impl PartialOrd<LioOpcode> for LioOpcode
impl PartialOrd<MmapAdvise> for MmapAdvise
impl PartialOrd<Event> for Event
impl PartialOrd<Request> for Request
impl PartialOrd<QuotaFmt> for QuotaFmt
impl PartialOrd<QuotaType> for QuotaType
impl PartialOrd<RebootMode> for RebootMode
impl PartialOrd<Resource> for Resource
impl PartialOrd<SigmaskHow> for SigmaskHow
impl PartialOrd<Signal> for Signal
impl PartialOrd<BaudRate> for BaudRate
impl PartialOrd<FlowArg> for FlowArg
impl PartialOrd<FlushArg> for FlushArg
impl PartialOrd<SetArg> for SetArg
impl PartialOrd<SpecialCharacterIndices> for SpecialCharacterIndices
impl PartialOrd<ClockId> for otter_api_tests::imports::nix::sys::timerfd::ClockId
impl PartialOrd<BigEndian> for BigEndian
impl PartialOrd<ErrorKind> for ErrorKind
impl PartialOrd<Infallible> for Infallible
impl PartialOrd<IpAddr> for IpAddr
impl PartialOrd<IpAddr> for Ipv4Addr
impl PartialOrd<IpAddr> for Ipv6Addr
impl PartialOrd<LittleEndian> for LittleEndian
impl PartialOrd<Ordering> for Ordering
impl PartialOrd<ProgressUpdateMode> for ProgressUpdateMode
impl PartialOrd<SocketAddr> for SocketAddr
impl PartialOrd<str> for OsStr
impl PartialOrd<usize> for LibInBundleI
impl PartialOrd<usize> for DescId
impl PartialOrd<usize> for SvgId
impl PartialOrd<usize> for FaceId
impl PartialOrd<usize> for Notch
impl PartialOrd<Id> for otter_api_tests::bundles::Id
impl PartialOrd<Index> for Index
impl PartialOrd<LibInBundleI> for LibInBundleI
impl PartialOrd<ZipIndex> for ZipIndex
impl PartialOrd<Error> for Error
impl PartialOrd<Duration> for otter_api_tests::imports::chrono::Duration
impl PartialOrd<IsoWeek> for IsoWeek
impl PartialOrd<NaiveDate> for NaiveDate
impl PartialOrd<NaiveDateTime> for NaiveDateTime
impl PartialOrd<NaiveTime> for NaiveTime
impl PartialOrd<ATerm> for ATerm
impl PartialOrd<B0> for B0
impl PartialOrd<B1> for B1
impl PartialOrd<Equal> for Equal
impl PartialOrd<Greater> for Greater
impl PartialOrd<Less> for Less
impl PartialOrd<UTerm> for UTerm
impl PartialOrd<Z0> for Z0
impl PartialOrd<MatchOptions> for MatchOptions
impl PartialOrd<Pattern> for Pattern
impl PartialOrd<TypeId> for TypeId
impl PartialOrd<CpuidResult> for CpuidResult
impl PartialOrd<PhantomPinned> for PhantomPinned
impl PartialOrd<NonZeroI8> for NonZeroI8
impl PartialOrd<NonZeroI16> for NonZeroI16
impl PartialOrd<NonZeroI32> for NonZeroI32
impl PartialOrd<NonZeroI64> for NonZeroI64
impl PartialOrd<NonZeroI128> for NonZeroI128
impl PartialOrd<NonZeroIsize> for NonZeroIsize
impl PartialOrd<NonZeroU8> for NonZeroU8
impl PartialOrd<NonZeroU16> for NonZeroU16
impl PartialOrd<NonZeroU32> for NonZeroU32
impl PartialOrd<NonZeroU64> for NonZeroU64
impl PartialOrd<NonZeroU128> for NonZeroU128
impl PartialOrd<AtFlags> for AtFlags
impl PartialOrd<FallocateFlags> for FallocateFlags
impl PartialOrd<FdFlag> for otter_api_tests::imports::nix::fcntl::FdFlag
impl PartialOrd<OFlag> for OFlag
impl PartialOrd<RenameFlags> for RenameFlags
impl PartialOrd<SealFlag> for SealFlag
impl PartialOrd<SpliceFFlags> for SpliceFFlags
impl PartialOrd<DeleteModuleFlags> for DeleteModuleFlags
impl PartialOrd<ModuleInitFlags> for ModuleInitFlags
impl PartialOrd<MntFlags> for MntFlags
impl PartialOrd<MsFlags> for otter_api_tests::imports::nix::mount::MsFlags
impl PartialOrd<FdFlag> for otter_api_tests::imports::nix::mqueue::FdFlag
impl PartialOrd<MQ_OFlag> for MQ_OFlag
impl PartialOrd<InterfaceFlags> for InterfaceFlags
impl PartialOrd<PollFlags> for PollFlags
impl PartialOrd<CloneFlags> for CloneFlags
impl PartialOrd<EpollCreateFlags> for EpollCreateFlags
impl PartialOrd<EpollFlags> for EpollFlags
impl PartialOrd<EfdFlags> for EfdFlags
impl PartialOrd<AddWatchFlags> for AddWatchFlags
impl PartialOrd<InitFlags> for InitFlags
impl PartialOrd<WatchDescriptor> for WatchDescriptor
impl PartialOrd<MemFdCreateFlag> for MemFdCreateFlag
impl PartialOrd<MRemapFlags> for MRemapFlags
impl PartialOrd<MapFlags> for MapFlags
impl PartialOrd<MlockAllFlags> for MlockAllFlags
impl PartialOrd<MsFlags> for otter_api_tests::imports::nix::sys::mman::MsFlags
impl PartialOrd<ProtFlags> for ProtFlags
impl PartialOrd<Persona> for Persona
impl PartialOrd<Options> for Options
impl PartialOrd<QuotaValidFlags> for QuotaValidFlags
impl PartialOrd<SaFlags> for SaFlags
impl PartialOrd<SfdFlags> for SfdFlags
impl PartialOrd<MsgFlags> for MsgFlags
impl PartialOrd<SockFlag> for SockFlag
impl PartialOrd<Mode> for Mode
impl PartialOrd<SFlag> for SFlag
impl PartialOrd<FsFlags> for FsFlags
impl PartialOrd<ControlFlags> for ControlFlags
impl PartialOrd<InputFlags> for InputFlags
impl PartialOrd<LocalFlags> for LocalFlags
impl PartialOrd<OutputFlags> for OutputFlags
impl PartialOrd<TimeVal> for TimeVal
impl PartialOrd<TimerFlags> for TimerFlags
impl PartialOrd<TimerSetTimeFlags> for TimerSetTimeFlags
impl PartialOrd<WaitPidFlag> for WaitPidFlag
impl PartialOrd<ClockId> for otter_api_tests::imports::nix::time::ClockId
impl PartialOrd<DefaultKey> for DefaultKey
impl PartialOrd<KeyData> for KeyData
impl PartialOrd<Fingerprint> for Fingerprint
impl PartialOrd<Id> for otter_api_tests::shapelib::sshkeys::Id
impl PartialOrd<KeySpec> for KeySpec
impl PartialOrd<Nonce> for Nonce
impl PartialOrd<DescId> for DescId
impl PartialOrd<Duration> for otter_api_tests::shapelib::Duration
impl PartialOrd<Instant> for otter_api_tests::shapelib::Instant
impl PartialOrd<Ipv4Addr> for IpAddr
impl PartialOrd<Ipv4Addr> for Ipv4Addr
impl PartialOrd<Ipv6Addr> for IpAddr
impl PartialOrd<Ipv6Addr> for Ipv6Addr
impl PartialOrd<NonZeroUsize> for NonZeroUsize
impl PartialOrd<OsStr> for OsStr
impl PartialOrd<PathBuf> for PathBuf
impl PartialOrd<SvgId> for SvgId
impl PartialOrd<TimeSpec> for TimeSpec
impl PartialOrd<Url> for Url
URLs compare like their serialization.