Trait kvarn::prelude::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<PathBuf> for OsString
impl<'a, 'b> PartialOrd<PathBuf> for OsString
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
sourceimpl PartialOrd<OsString> for OsString
impl PartialOrd<OsString> for OsString
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Path> for &'a OsStr
impl<'a, 'b> PartialOrd<Path> for &'a OsStr
fn partial_cmp(&self, other: &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<Component<'a>> for Component<'a>
impl<'a> PartialOrd<Component<'a>> for Component<'a>
fn partial_cmp(&self, other: &Component<'a>) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for OsStr
impl<'a, 'b> PartialOrd<OsString> for OsStr
fn partial_cmp(&self, other: &OsString) -> Option<Ordering>
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 OsString
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString
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.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'a Path> for OsStr
impl<'a, 'b> PartialOrd<&'a Path> for OsStr
fn partial_cmp(&self, other: &&'a Path) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr
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<Cow<'a, OsStr>> for OsStr
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for &'a OsStr
impl<'a, 'b> PartialOrd<OsString> for &'a OsStr
fn partial_cmp(&self, other: &OsString) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Path> for OsStr
impl<'a, 'b> PartialOrd<Path> for OsStr
fn partial_cmp(&self, other: &Path) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr
sourceimpl PartialOrd<str> for OsString
impl PartialOrd<str> for OsString
fn partial_cmp(&self, other: &str) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<PathBuf> for OsStr
impl<'a, 'b> PartialOrd<PathBuf> for OsStr
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
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>
sourceimpl PartialOrd<str> for OsStr
impl PartialOrd<str> for OsStr
fn partial_cmp(&self, other: &str) -> Option<Ordering>
sourceimpl PartialOrd<OsStr> for OsStr
impl PartialOrd<OsStr> for OsStr
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 PartialOrd<SystemTime> for SystemTime
impl PartialOrd<SystemTime> for SystemTime
fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering>
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>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr
impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
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>
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, 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>
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>
sourceimpl PartialOrd<f32> for f32
impl PartialOrd<f32> for f32
1.33.0 · sourceimpl PartialOrd<PhantomPinned> for PhantomPinned
impl PartialOrd<PhantomPinned> for PhantomPinned
fn partial_cmp(&self, other: &PhantomPinned) -> 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<i32> for i32
impl PartialOrd<i32> for i32
sourceimpl<B, C, D, E, F, G, H, I, J, K, L> PartialOrd<(B, C, D, E, F, G, H, I, J, K, L)> for (B, C, D, E, F, G, H, I, J, K, L) where
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<B, C, D, E, F, G, H, I, J, K, L> PartialOrd<(B, C, D, E, F, G, H, I, J, K, L)> for (B, C, D, E, F, G, H, I, J, K, L) where
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: &(B, C, D, E, F, G, H, I, J, K, L)
) -> Option<Ordering>
fn lt(&self, other: &(B, C, D, E, F, G, H, I, J, K, L)) -> bool
fn le(&self, other: &(B, C, D, E, F, G, H, I, J, K, L)) -> bool
fn ge(&self, other: &(B, C, D, E, F, G, H, I, J, K, L)) -> bool
fn gt(&self, other: &(B, C, D, E, F, G, H, I, J, K, L)) -> bool
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, 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> 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, 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<T> PartialOrd<Option<T>> for Option<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<Option<T>> for Option<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &Option<T>) -> Option<Ordering>
sourceimpl PartialOrd<!> for !
impl PartialOrd<!> for !
fn partial_cmp(&self, &!) -> Option<Ordering>
1.28.0 · sourceimpl PartialOrd<NonZeroUsize> for NonZeroUsize
impl PartialOrd<NonZeroUsize> for NonZeroUsize
fn partial_cmp(&self, other: &NonZeroUsize) -> 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>
sourceimpl PartialOrd<i128> for i128
impl PartialOrd<i128> for i128
sourceimpl PartialOrd<Which> for Which
impl PartialOrd<Which> for Which
fn partial_cmp(&self, other: &Which) -> Option<Ordering>
sourceimpl PartialOrd<isize> for isize
impl PartialOrd<isize> for isize
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<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &Wrapping<T>) -> 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.34.0 · sourceimpl PartialOrd<Infallible> for Infallible
impl PartialOrd<Infallible> for Infallible
fn partial_cmp(&self, _other: &Infallible) -> 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<G, H, I, J, K, L> PartialOrd<(G, H, I, J, K, L)> for (G, H, I, J, K, L) where
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<G, H, I, J, K, L> PartialOrd<(G, H, I, J, K, L)> for (G, H, I, J, K, L) where
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,
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>
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>
1.20.0 · sourceimpl<T> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialOrd<T> + ?Sized,
impl<T> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialOrd<T> + ?Sized,
fn partial_cmp(&self, other: &ManuallyDrop<T>) -> Option<Ordering>
sourceimpl PartialOrd<usize> for usize
impl PartialOrd<usize> for usize
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> 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<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.34.0 · sourceimpl PartialOrd<NonZeroI16> for NonZeroI16
impl PartialOrd<NonZeroI16> for NonZeroI16
fn partial_cmp(&self, other: &NonZeroI16) -> 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> 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>
sourceimpl<D, E, F, G, H, I, J, K, L> PartialOrd<(D, E, F, G, H, I, J, K, L)> for (D, E, F, G, H, I, J, K, L) where
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<D, E, F, G, H, I, J, K, L> PartialOrd<(D, E, F, G, H, I, J, K, L)> for (D, E, F, G, H, I, J, K, L) where
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: &(D, E, F, G, H, I, J, K, L)) -> Option<Ordering>
fn lt(&self, other: &(D, E, F, G, H, I, J, K, L)) -> bool
fn le(&self, other: &(D, E, F, G, H, I, J, K, L)) -> bool
fn ge(&self, other: &(D, E, F, G, H, I, J, K, L)) -> bool
fn gt(&self, other: &(D, E, F, G, H, I, J, K, L)) -> bool
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> 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>
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,
sourceimpl PartialOrd<TypeId> for TypeId
impl PartialOrd<TypeId> for TypeId
fn partial_cmp(&self, other: &TypeId) -> 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.34.0 · sourceimpl PartialOrd<NonZeroI32> for NonZeroI32
impl PartialOrd<NonZeroI32> for NonZeroI32
fn partial_cmp(&self, other: &NonZeroI32) -> 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> 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.28.0 · sourceimpl PartialOrd<NonZeroU64> for NonZeroU64
impl PartialOrd<NonZeroU64> for NonZeroU64
fn partial_cmp(&self, other: &NonZeroU64) -> 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.10.0 · sourceimpl<'a> PartialOrd<Location<'a>> for Location<'a>
impl<'a> PartialOrd<Location<'a>> for Location<'a>
fn partial_cmp(&self, other: &Location<'a>) -> Option<Ordering>
sourceimpl<K, L> PartialOrd<(K, L)> for (K, L) where
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
impl<K, L> PartialOrd<(K, L)> for (K, L) where
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
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<H, I, J, K, L> PartialOrd<(H, I, J, K, L)> for (H, I, J, K, L) where
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<H, I, J, K, L> PartialOrd<(H, I, J, K, L)> for (H, I, J, K, L) where
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,
1.28.0 · sourceimpl PartialOrd<NonZeroU32> for NonZeroU32
impl PartialOrd<NonZeroU32> for NonZeroU32
fn partial_cmp(&self, other: &NonZeroU32) -> 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.10.0 · sourceimpl<T> PartialOrd<RefCell<T>> for RefCell<T> where
T: PartialOrd<T> + ?Sized,
impl<T> PartialOrd<RefCell<T>> for RefCell<T> where
T: PartialOrd<T> + ?Sized,
sourcefn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>
fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>
Panics
Panics if the value in either RefCell
is currently borrowed.
sourcefn lt(&self, other: &RefCell<T>) -> bool
fn lt(&self, other: &RefCell<T>) -> bool
Panics
Panics if the value in either RefCell
is currently borrowed.
sourcefn le(&self, other: &RefCell<T>) -> bool
fn le(&self, other: &RefCell<T>) -> bool
Panics
Panics if the value in either RefCell
is currently borrowed.
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> 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>
sourceimpl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES> where
T: SimdElement + PartialOrd<T>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES> where
T: SimdElement + PartialOrd<T>,
LaneCount<LANES>: SupportedLaneCount,
fn partial_cmp(&self, other: &Simd<T, LANES>) -> 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.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>
sourceimpl PartialOrd<i8> for i8
impl PartialOrd<i8> for i8
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> 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<i16> for i16
impl PartialOrd<i16> for i16
sourceimpl PartialOrd<i64> for i64
impl PartialOrd<i64> for i64
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>
sourceimpl<F, G, H, I, J, K, L> PartialOrd<(F, G, H, I, J, K, L)> for (F, G, H, I, J, K, L) where
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<F, G, H, I, J, K, L> PartialOrd<(F, G, H, I, J, K, L)> for (F, G, H, I, J, K, L) where
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: &(F, G, H, I, J, K, L)) -> Option<Ordering>
fn lt(&self, other: &(F, G, H, I, J, K, L)) -> bool
fn le(&self, other: &(F, G, H, I, J, K, L)) -> bool
fn ge(&self, other: &(F, G, H, I, J, K, L)) -> bool
fn gt(&self, other: &(F, G, H, I, J, K, L)) -> bool
sourceimpl<T, const LANES: usize> PartialOrd<Mask<T, LANES>> for Mask<T, LANES> where
T: MaskElement + PartialOrd<T>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> PartialOrd<Mask<T, LANES>> for Mask<T, LANES> where
T: MaskElement + PartialOrd<T>,
LaneCount<LANES>: SupportedLaneCount,
fn partial_cmp(&self, other: &Mask<T, LANES>) -> Option<Ordering>
sourceimpl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
fn partial_cmp(&self, _other: &PhantomData<T>) -> 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>
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.34.0 · sourceimpl PartialOrd<NonZeroIsize> for NonZeroIsize
impl PartialOrd<NonZeroIsize> for NonZeroIsize
fn partial_cmp(&self, other: &NonZeroIsize) -> 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.34.0 · sourceimpl PartialOrd<NonZeroI128> for NonZeroI128
impl PartialOrd<NonZeroI128> for NonZeroI128
fn partial_cmp(&self, other: &NonZeroI128) -> Option<Ordering>
sourceimpl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
Y: PartialOrd<Y>,
R: PartialOrd<R>,
impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
Y: PartialOrd<Y>,
R: PartialOrd<R>,
fn partial_cmp(&self, other: &GeneratorState<Y, R>) -> Option<Ordering>
sourceimpl PartialOrd<CStr> for CStr
impl PartialOrd<CStr> for CStr
fn partial_cmp(&self, other: &CStr) -> 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>
sourceimpl PartialOrd<f64> for f64
impl PartialOrd<f64> for f64
sourceimpl<I, J, K, L> PartialOrd<(I, J, K, L)> for (I, J, K, L) where
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
impl<I, J, K, L> PartialOrd<(I, J, K, L)> for (I, J, K, L) where
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
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.28.0 · sourceimpl PartialOrd<NonZeroU8> for NonZeroU8
impl PartialOrd<NonZeroU8> for NonZeroU8
fn partial_cmp(&self, other: &NonZeroU8) -> Option<Ordering>
sourceimpl PartialOrd<u8> for u8
impl PartialOrd<u8> for u8
sourceimpl PartialOrd<u32> for u32
impl PartialOrd<u32> for u32
sourceimpl<J, K, L> PartialOrd<(J, K, L)> for (J, K, L) where
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
impl<J, K, L> PartialOrd<(J, K, L)> for (J, K, L) where
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K>,
L: PartialOrd<L> + PartialEq<L> + ?Sized,
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>
sourceimpl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
impl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
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>
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.34.0 · sourceimpl PartialOrd<NonZeroI8> for NonZeroI8
impl PartialOrd<NonZeroI8> for NonZeroI8
fn partial_cmp(&self, other: &NonZeroI8) -> 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, 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> 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> 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>
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>
sourceimpl PartialOrd<u16> for u16
impl PartialOrd<u16> for u16
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, 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> 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> 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> 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.28.0 · sourceimpl PartialOrd<NonZeroU16> for NonZeroU16
impl PartialOrd<NonZeroU16> for NonZeroU16
fn partial_cmp(&self, other: &NonZeroU16) -> 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<char> for char
impl PartialOrd<char> for char
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> 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> 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, 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<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, 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<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<E, F, G, H, I, J, K, L> PartialOrd<(E, F, G, H, I, J, K, L)> for (E, F, G, H, I, J, K, L) where
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<E, F, G, H, I, J, K, L> PartialOrd<(E, F, G, H, I, J, K, L)> for (E, F, G, H, I, J, K, L) where
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: &(E, F, G, H, I, J, K, L)) -> Option<Ordering>
fn lt(&self, other: &(E, F, G, H, I, J, K, L)) -> bool
fn le(&self, other: &(E, F, G, H, I, J, K, L)) -> bool
fn ge(&self, other: &(E, F, G, H, I, J, K, L)) -> bool
fn gt(&self, other: &(E, F, G, H, I, J, K, L)) -> bool
1.10.0 · sourceimpl<T> PartialOrd<Cell<T>> for Cell<T> where
T: PartialOrd<T> + Copy,
impl<T> PartialOrd<Cell<T>> for Cell<T> where
T: PartialOrd<T> + Copy,
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, 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<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>,
sourceimpl<C, D, E, F, G, H, I, J, K, L> PartialOrd<(C, D, E, F, G, H, I, J, K, L)> for (C, D, E, F, G, H, I, J, K, L) where
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<C, D, E, F, G, H, I, J, K, L> PartialOrd<(C, D, E, F, G, H, I, J, K, L)> for (C, D, E, F, G, H, I, J, K, L) where
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: &(C, D, E, F, G, H, I, J, K, L)
) -> Option<Ordering>
fn lt(&self, other: &(C, D, E, F, G, H, I, J, K, L)) -> bool
fn le(&self, other: &(C, D, E, F, G, H, I, J, K, L)) -> bool
fn ge(&self, other: &(C, D, E, F, G, H, I, J, K, L)) -> bool
fn gt(&self, other: &(C, D, E, F, G, H, I, J, K, L)) -> bool
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>
1.27.0 · sourceimpl PartialOrd<CpuidResult> for CpuidResult
impl PartialOrd<CpuidResult> for CpuidResult
fn partial_cmp(&self, other: &CpuidResult) -> 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> 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> 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>
sourceimpl<L> PartialOrd<(L,)> for (L,) where
L: PartialOrd<L> + PartialEq<L> + ?Sized,
impl<L> PartialOrd<(L,)> for (L,) where
L: PartialOrd<L> + PartialEq<L> + ?Sized,
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, 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, 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>
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> 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> 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.34.0 · sourceimpl PartialOrd<NonZeroI64> for NonZeroI64
impl PartialOrd<NonZeroI64> for NonZeroI64
fn partial_cmp(&self, other: &NonZeroI64) -> 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>
sourceimpl PartialOrd<u128> for u128
impl PartialOrd<u128> for u128
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, 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> 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> 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> 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<T> PartialOrd<Saturating<T>> for Saturating<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<Saturating<T>> for Saturating<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &Saturating<T>) -> 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<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
T: PartialOrd<T>,
E: PartialOrd<E>,
impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where
T: PartialOrd<T>,
E: PartialOrd<E>,
fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>
1.28.0 · sourceimpl PartialOrd<NonZeroU128> for NonZeroU128
impl PartialOrd<NonZeroU128> for NonZeroU128
fn partial_cmp(&self, other: &NonZeroU128) -> 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>
sourceimpl PartialOrd<u64> for u64
impl PartialOrd<u64> for u64
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,
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>
sourceimpl PartialOrd<bool> for bool
impl PartialOrd<bool> for bool
fn partial_cmp(&self, other: &bool) -> 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, 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<String> for String
impl PartialOrd<String> for String
fn partial_cmp(&self, other: &String) -> Option<Ordering>
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> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &BTreeSet<T>) -> Option<Ordering>
sourceimpl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialOrd<K>,
V: PartialOrd<V>,
impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialOrd<K>,
V: PartialOrd<V>,
fn partial_cmp(&self, other: &BTreeMap<K, V>) -> 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, A> PartialOrd<VecDeque<T, A>> for VecDeque<T, A> where
T: PartialOrd<T>,
A: Allocator,
impl<T, A> PartialOrd<VecDeque<T, A>> for VecDeque<T, A> where
T: PartialOrd<T>,
A: Allocator,
fn partial_cmp(&self, other: &VecDeque<T, A>) -> Option<Ordering>
sourceimpl PartialOrd<CString> for CString
impl PartialOrd<CString> for CString
fn partial_cmp(&self, other: &CString) -> Option<Ordering>
sourceimpl PartialOrd<Certificate> for Certificate
impl PartialOrd<Certificate> for Certificate
fn partial_cmp(&self, other: &Certificate) -> Option<Ordering>
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
sourceimpl<'a> PartialOrd<Metadata<'a>> for Metadata<'a>
impl<'a> PartialOrd<Metadata<'a>> for Metadata<'a>
fn partial_cmp(&self, other: &Metadata<'a>) -> Option<Ordering>
sourceimpl PartialOrd<Level> for LevelFilter
impl PartialOrd<Level> for LevelFilter
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 Level
impl PartialOrd<Level> for Level
sourceimpl<'a> PartialOrd<MetadataBuilder<'a>> for MetadataBuilder<'a>
impl<'a> PartialOrd<MetadataBuilder<'a>> for MetadataBuilder<'a>
fn partial_cmp(&self, other: &MetadataBuilder<'a>) -> Option<Ordering>
sourceimpl PartialOrd<Time> for Time
impl PartialOrd<Time> for Time
fn partial_cmp(&self, other: &Time) -> Option<Ordering>
sourceimpl PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, other: &Instant) -> Option<Ordering>
sourceimpl PartialOrd<Ready> for Ready
impl PartialOrd<Ready> for Ready
fn partial_cmp(&self, other: &Ready) -> 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 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>
sourceimpl PartialOrd<Bytes> for Vec<u8, Global>
impl PartialOrd<Bytes> for Vec<u8, Global>
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
sourceimpl PartialOrd<Bytes> for str
impl PartialOrd<Bytes> for str
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
sourceimpl PartialOrd<BytesMut> for Vec<u8, Global>
impl PartialOrd<BytesMut> for Vec<u8, Global>
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
sourceimpl PartialOrd<BytesMut> for [u8]
impl PartialOrd<BytesMut> for [u8]
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
sourceimpl PartialOrd<BytesMut> for String
impl PartialOrd<BytesMut> for String
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
sourceimpl PartialOrd<Bytes> for String
impl PartialOrd<Bytes> for String
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
sourceimpl<'_> PartialOrd<BytesMut> for &'_ [u8]
impl<'_> PartialOrd<BytesMut> for &'_ [u8]
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
sourceimpl<'_> PartialOrd<Bytes> for &'_ str
impl<'_> PartialOrd<Bytes> for &'_ str
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
sourceimpl<'_> PartialOrd<BytesMut> for &'_ str
impl<'_> PartialOrd<BytesMut> for &'_ str
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
sourceimpl<'_> PartialOrd<Bytes> for &'_ [u8]
impl<'_> PartialOrd<Bytes> for &'_ [u8]
fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>
sourceimpl PartialOrd<BytesMut> for str
impl PartialOrd<BytesMut> for str
fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>
sourceimpl PartialOrd<ASN1Time> for ASN1Time
impl PartialOrd<ASN1Time> for ASN1Time
fn partial_cmp(&self, other: &ASN1Time) -> Option<Ordering>
impl PartialOrd<ASN1DateTime> for ASN1DateTime
impl PartialOrd<ASN1DateTime> for ASN1DateTime
fn partial_cmp(&self, other: &ASN1DateTime) -> Option<Ordering>
impl PartialOrd<UtcTime> for UtcTime
impl PartialOrd<UtcTime> for UtcTime
fn partial_cmp(&self, other: &UtcTime) -> Option<Ordering>
impl PartialOrd<ASN1TimeZone> for ASN1TimeZone
impl PartialOrd<ASN1TimeZone> for ASN1TimeZone
fn partial_cmp(&self, other: &ASN1TimeZone) -> Option<Ordering>
impl PartialOrd<GeneralizedTime> for GeneralizedTime
impl PartialOrd<GeneralizedTime> for GeneralizedTime
fn partial_cmp(&self, other: &GeneralizedTime) -> Option<Ordering>
sourceimpl PartialOrd<OffsetDateTime> for SystemTime
Available on crate feature std
only.
impl PartialOrd<OffsetDateTime> for SystemTime
std
only.fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering>
sourceimpl PartialOrd<Time> for Time
impl PartialOrd<Time> for Time
fn partial_cmp(&self, other: &Time) -> Option<Ordering>
sourceimpl PartialOrd<Duration> for Duration
impl PartialOrd<Duration> for Duration
fn partial_cmp(&self, rhs: &Duration) -> Option<Ordering>
sourceimpl PartialOrd<UtcOffset> for UtcOffset
impl PartialOrd<UtcOffset> for UtcOffset
fn partial_cmp(&self, other: &UtcOffset) -> Option<Ordering>
sourceimpl PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, other: &Instant) -> Option<Ordering>
sourceimpl PartialOrd<PrimitiveDateTime> for PrimitiveDateTime
impl PartialOrd<PrimitiveDateTime> for PrimitiveDateTime
fn partial_cmp(&self, other: &PrimitiveDateTime) -> Option<Ordering>
sourceimpl PartialOrd<Date> for Date
impl PartialOrd<Date> for Date
fn partial_cmp(&self, other: &Date) -> Option<Ordering>
sourceimpl PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, rhs: &Instant) -> Option<Ordering>
sourceimpl PartialOrd<Duration> for Duration
impl PartialOrd<Duration> for Duration
fn partial_cmp(&self, other: &Duration) -> 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>
sourceimpl PartialOrd<Sign> for Sign
impl PartialOrd<Sign> for Sign
fn partial_cmp(&self, other: &Sign) -> Option<Ordering>
sourceimpl PartialOrd<HeaderValue> for String
impl PartialOrd<HeaderValue> for String
fn partial_cmp(&self, other: &HeaderValue) -> 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<PathAndQuery> for String
impl PartialOrd<PathAndQuery> for String
fn partial_cmp(&self, other: &PathAndQuery) -> 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<HeaderValue> for &'a str
impl<'a> PartialOrd<HeaderValue> for &'a str
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<Authority> for str
impl PartialOrd<Authority> for str
fn partial_cmp(&self, other: &Authority) -> Option<Ordering>
sourceimpl PartialOrd<PathAndQuery> for str
impl PartialOrd<PathAndQuery> for str
fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>
sourceimpl PartialOrd<Authority> for String
impl PartialOrd<Authority> for String
fn partial_cmp(&self, other: &Authority) -> Option<Ordering>
sourceimpl PartialOrd<HeaderValue> for str
impl PartialOrd<HeaderValue> for str
fn partial_cmp(&self, other: &HeaderValue) -> 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<T> PartialOrd<Ascii<T>> for Ascii<T> where
T: AsRef<str>,
Available on __unicase__iter_cmp
only.
impl<T> PartialOrd<Ascii<T>> for Ascii<T> where
T: AsRef<str>,
__unicase__iter_cmp
only.fn partial_cmp(&self, other: &Ascii<T>) -> Option<Ordering>
sourceimpl<T> PartialOrd<UniCase<T>> for UniCase<T> where
T: AsRef<str>,
Available on __unicase__iter_cmp
only.
impl<T> PartialOrd<UniCase<T>> for UniCase<T> where
T: AsRef<str>,
__unicase__iter_cmp
only.fn partial_cmp(&self, other: &UniCase<T>) -> Option<Ordering>
impl PartialOrd<BytesCodec> for BytesCodec
impl PartialOrd<BytesCodec> for BytesCodec
fn partial_cmp(&self, other: &BytesCodec) -> Option<Ordering>
impl PartialOrd<LinesCodec> for LinesCodec
impl PartialOrd<LinesCodec> for LinesCodec
fn partial_cmp(&self, other: &LinesCodec) -> Option<Ordering>
impl PartialOrd<AnyDelimiterCodec> for AnyDelimiterCodec
impl PartialOrd<AnyDelimiterCodec> for AnyDelimiterCodec
fn partial_cmp(&self, other: &AnyDelimiterCodec) -> 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
Implementors
impl PartialOrd<Action> for Action
impl PartialOrd<Ordering> for Ordering
impl PartialOrd<IpAddr> for IpAddr
impl PartialOrd<IpAddr> for Ipv4Addr
impl PartialOrd<IpAddr> for Ipv6Addr
impl PartialOrd<SocketAddr> for SocketAddr
impl PartialOrd<ErrorKind> for ErrorKind
impl PartialOrd<RequestParseStage> for RequestParseStage
impl PartialOrd<[u8]> for Bytes
impl PartialOrd<[u8]> for BytesMut
impl PartialOrd<[u8]> for HeaderValue
impl PartialOrd<str> for Bytes
impl PartialOrd<str> for BytesMut
impl PartialOrd<str> for HeaderValue
impl PartialOrd<str> for Authority
impl PartialOrd<str> for PathAndQuery
impl PartialOrd<Id> for Id
impl PartialOrd<OffsetDateTime> for OffsetDateTime
impl PartialOrd<Error> for Error
impl PartialOrd<String> for Bytes
impl PartialOrd<String> for BytesMut
impl PartialOrd<String> for HeaderValue
impl PartialOrd<String> for Authority
impl PartialOrd<String> for PathAndQuery
impl PartialOrd<Vec<u8, Global>> for Bytes
impl PartialOrd<Vec<u8, Global>> for BytesMut
impl PartialOrd<SystemTime> for OffsetDateTime
std
only.impl PartialOrd<Duration> for kvarn::prelude::Duration
impl PartialOrd<Instant> for kvarn::prelude::Instant
impl PartialOrd<Mime> for Mime
impl PartialOrd<Ipv4Addr> for IpAddr
impl PartialOrd<Ipv4Addr> for Ipv4Addr
impl PartialOrd<Ipv6Addr> for IpAddr
impl PartialOrd<Ipv6Addr> for Ipv6Addr
impl PartialOrd<SocketAddrV4> for SocketAddrV4
impl PartialOrd<SocketAddrV6> for SocketAddrV6
impl PartialOrd<Bytes> for Bytes
impl PartialOrd<BytesMut> for BytesMut
impl PartialOrd<Duration> for kvarn::prelude::Duration
impl PartialOrd<HeaderValue> for HeaderValue
impl PartialOrd<Instant> for kvarn::prelude::Instant
impl PartialOrd<Path> for Path
impl PartialOrd<PathBuf> for PathBuf
impl PartialOrd<StatusCode> for StatusCode
impl PartialOrd<Version> for Version
impl PartialOrd<Authority> for Authority
Case-insensitive ordering
Examples
let authority: Authority = "DEF.com".parse().unwrap();
assert!(authority < "ghi.com");
assert!(authority > "abc.com");