Trait scale_info::prelude::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<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 &'b OsStr
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for &'b OsStr
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>
1.7.0 · sourceimpl PartialOrd<IpAddr> for IpAddr
impl PartialOrd<IpAddr> for IpAddr
fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for PathBuf
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
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>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path
impl<'a, 'b> PartialOrd<Cow<'b, OsStr>> for &'a Path
1.8.0 · sourceimpl PartialOrd<SystemTime> for SystemTime
impl PartialOrd<SystemTime> for SystemTime
fn partial_cmp(&self, other: &SystemTime) -> 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 Path
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path
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<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<&'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<OsStr> for PathBuf
impl<'a, 'b> PartialOrd<OsStr> for PathBuf
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
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<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<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 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<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<Cow<'a, Path>> for OsString
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsString
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.8.0 · sourceimpl<'a, 'b> PartialOrd<&'a Path> for PathBuf
impl<'a, 'b> PartialOrd<&'a Path> for PathBuf
fn partial_cmp(&self, other: &&'a Path) -> 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>
sourceimpl PartialOrd<OsStr> for OsStr
impl PartialOrd<OsStr> for OsStr
sourceimpl PartialOrd<SocketAddr> for SocketAddr
impl PartialOrd<SocketAddr> for SocketAddr
fn partial_cmp(&self, other: &SocketAddr) -> 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<Ipv6Addr> for Ipv6Addr
impl PartialOrd<Ipv6Addr> for Ipv6Addr
fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>
1.16.0 · sourceimpl PartialOrd<Ipv4Addr> for IpAddr
impl PartialOrd<Ipv4Addr> for IpAddr
fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>
1.16.0 · sourceimpl PartialOrd<Ipv6Addr> for IpAddr
impl PartialOrd<Ipv6Addr> for IpAddr
fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>
sourceimpl PartialOrd<OsString> for OsString
impl PartialOrd<OsString> for OsString
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<Cow<'a, Path>> for OsStr
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr
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<'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<OsStr> for Path
impl<'a, 'b> PartialOrd<OsStr> for Path
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
sourceimpl PartialOrd<Ipv4Addr> for Ipv4Addr
impl PartialOrd<Ipv4Addr> for Ipv4Addr
fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString
1.16.0 · sourceimpl PartialOrd<IpAddr> for Ipv4Addr
impl PartialOrd<IpAddr> for Ipv4Addr
fn partial_cmp(&self, other: &IpAddr) -> 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.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<PathBuf> for Path
impl<'a, 'b> PartialOrd<PathBuf> for Path
fn partial_cmp(&self, other: &PathBuf) -> 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, OsStr>> for PathBuf
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for PathBuf
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
1.16.0 · sourceimpl PartialOrd<IpAddr> for Ipv6Addr
impl PartialOrd<IpAddr> for Ipv6Addr
fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Path> for PathBuf
impl<'a, 'b> PartialOrd<Path> for PathBuf
fn partial_cmp(&self, other: &Path) -> 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<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, Path>> for Path
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path
sourceimpl PartialOrd<ErrorKind> for ErrorKind
impl PartialOrd<ErrorKind> for ErrorKind
fn partial_cmp(&self, other: &ErrorKind) -> Option<Ordering>
sourceimpl PartialOrd<str> for OsStr
impl PartialOrd<str> for OsStr
fn partial_cmp(&self, other: &str) -> 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<PathBuf> for PathBuf
impl PartialOrd<PathBuf> for PathBuf
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for PathBuf
impl<'a, 'b> PartialOrd<OsString> for PathBuf
fn partial_cmp(&self, other: &OsString) -> Option<Ordering>
sourceimpl PartialOrd<str> for OsString
impl PartialOrd<str> for OsString
fn partial_cmp(&self, other: &str) -> Option<Ordering>
1.8.0 · sourceimpl PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, other: &Instant) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf
impl<'a, 'b> PartialOrd<&'a OsStr> for PathBuf
fn partial_cmp(&self, other: &&'a OsStr) -> 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.36.0 · sourceimpl<T> PartialOrd<Poll<T>> for Poll<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<Poll<T>> for Poll<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &Poll<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>
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>
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<()> for ()
impl PartialOrd<()> for ()
fn partial_cmp(&self, &()) -> 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> 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> 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<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> 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, 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>
sourceimpl PartialOrd<i8> for i8
impl PartialOrd<i8> for i8
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> 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, 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, 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> 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 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<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, 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>
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, 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> 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<bool> for bool
impl PartialOrd<bool> for bool
fn partial_cmp(&self, other: &bool) -> Option<Ordering>
sourceimpl PartialOrd<i128> for i128
impl PartialOrd<i128> for i128
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, 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, 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>
sourceimpl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
impl<T> PartialOrd<*const T> for *const T where
T: ?Sized,
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>
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, 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.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, 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<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>
sourceimpl PartialOrd<char> for char
impl PartialOrd<char> for char
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> 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<i32> for i32
impl PartialOrd<i32> for i32
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>
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,
sourceimpl PartialOrd<i64> for i64
impl PartialOrd<i64> for i64
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<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.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,
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 PartialOrd<isize> for isize
impl PartialOrd<isize> for isize
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>
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,
sourceimpl PartialOrd<u128> for u128
impl PartialOrd<u128> for u128
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<u64> for u64
impl PartialOrd<u64> for u64
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> 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<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.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> 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<u32> for u32
impl PartialOrd<u32> for u32
1.3.0 · sourceimpl PartialOrd<Duration> for Duration
impl PartialOrd<Duration> for Duration
fn partial_cmp(&self, other: &Duration) -> 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> 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<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> 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> 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>
1.41.0 · sourceimpl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialOrd<<Q as Deref>::Target>,
impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialOrd<<Q as Deref>::Target>,
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>
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> 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<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>
sourceimpl PartialOrd<i16> for i16
impl PartialOrd<i16> for i16
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> 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> 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<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<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.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.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>
sourceimpl PartialOrd<CStr> for CStr
impl PartialOrd<CStr> for CStr
fn partial_cmp(&self, other: &CStr) -> 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, 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, 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> 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> 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>
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, 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> 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, 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 PartialOrd<u8> for u8
impl PartialOrd<u8> for u8
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,
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> 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> 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> 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, 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<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, 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>
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 PartialOrd<f64> for f64
impl PartialOrd<f64> for f64
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, 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>
sourceimpl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
impl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
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.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> 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, 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<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
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<Which> for Which
impl PartialOrd<Which> for Which
fn partial_cmp(&self, other: &Which) -> Option<Ordering>
sourceimpl PartialOrd<!> for !
impl PartialOrd<!> for !
fn partial_cmp(&self, &!) -> Option<Ordering>
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, 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>
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<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> 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<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
sourceimpl PartialOrd<usize> for usize
impl PartialOrd<usize> for usize
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> 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>
sourceimpl PartialOrd<u16> for u16
impl PartialOrd<u16> for u16
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<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 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<Arc<T>> for Arc<T> where
T: PartialOrd<T> + ?Sized,
impl<T> PartialOrd<Arc<T>> for Arc<T> where
T: PartialOrd<T> + ?Sized,
sourcefn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>
fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>
Partial comparison for two Arc
s.
The two are compared by calling partial_cmp()
on their inner values.
Examples
use std::sync::Arc;
use std::cmp::Ordering;
let five = Arc::new(5);
assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));
sourcefn lt(&self, other: &Arc<T>) -> bool
fn lt(&self, other: &Arc<T>) -> bool
Less-than comparison for two Arc
s.
The two are compared by calling <
on their inner values.
Examples
use std::sync::Arc;
let five = Arc::new(5);
assert!(five < Arc::new(6));
sourcefn le(&self, other: &Arc<T>) -> bool
fn le(&self, other: &Arc<T>) -> bool
‘Less than or equal to’ comparison for two Arc
s.
The two are compared by calling <=
on their inner values.
Examples
use std::sync::Arc;
let five = Arc::new(5);
assert!(five <= Arc::new(5));
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 PartialOrd<CString> for CString
impl PartialOrd<CString> for CString
fn partial_cmp(&self, other: &CString) -> Option<Ordering>
sourceimpl<T> PartialOrd<Compact<T>> for Compact<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<Compact<T>> for Compact<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &Compact<T>) -> Option<Ordering>
sourceimpl<T, const CAP: usize> PartialOrd<ArrayVec<T, CAP>> for ArrayVec<T, CAP> where
T: PartialOrd<T>,
impl<T, const CAP: usize> PartialOrd<ArrayVec<T, CAP>> for ArrayVec<T, CAP> where
T: PartialOrd<T>,
sourceimpl<const CAP: usize> PartialOrd<str> for ArrayString<CAP>
impl<const CAP: usize> PartialOrd<str> for ArrayString<CAP>
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<T> PartialOrd<CapacityError<T>> for CapacityError<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<CapacityError<T>> for CapacityError<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &CapacityError<T>) -> Option<Ordering>
sourceimpl<const CAP: usize> PartialOrd<ArrayString<CAP>> for ArrayString<CAP>
impl<const CAP: usize> PartialOrd<ArrayString<CAP>> for ArrayString<CAP>
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<R> PartialOrd<BitMask<R>> for BitMask<R> where
R: PartialOrd<R> + BitRegister,
impl<R> PartialOrd<BitMask<R>> for BitMask<R> where
R: PartialOrd<R> + BitRegister,
fn partial_cmp(&self, other: &BitMask<R>) -> Option<Ordering>
sourceimpl<'a, T, O> PartialOrd<IterZeros<'a, T, O>> for IterZeros<'a, T, O> where
T: PartialOrd<T> + 'a + BitStore,
O: PartialOrd<O> + BitOrder,
impl<'a, T, O> PartialOrd<IterZeros<'a, T, O>> for IterZeros<'a, T, O> where
T: PartialOrd<T> + 'a + BitStore,
O: PartialOrd<O> + BitOrder,
fn partial_cmp(&self, other: &IterZeros<'a, T, O>) -> Option<Ordering>
sourceimpl<R> PartialOrd<BitPos<R>> for BitPos<R> where
R: PartialOrd<R> + BitRegister,
impl<R> PartialOrd<BitPos<R>> for BitPos<R> where
R: PartialOrd<R> + BitRegister,
fn partial_cmp(&self, other: &BitPos<R>) -> Option<Ordering>
sourceimpl<'_, '_, T1, T2, O1, O2> PartialOrd<&'_ mut BitSlice<T2, O2>> for &'_ BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'_, '_, T1, T2, O1, O2> PartialOrd<&'_ mut BitSlice<T2, O2>> for &'_ BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, rhs: &&mut BitSlice<T2, O2>) -> Option<Ordering>
sourceimpl PartialOrd<Lsb0> for Lsb0
impl PartialOrd<Lsb0> for Lsb0
fn partial_cmp(&self, other: &Lsb0) -> Option<Ordering>
sourceimpl<'a, T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for &'a BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'a, T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for &'a BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, other: &BitVec<T2, O2>) -> Option<Ordering>
sourceimpl<T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, other: &BitVec<T2, O2>) -> Option<Ordering>
sourceimpl<'_, '_, M, T, O> PartialOrd<&'_ bool> for BitRef<'_, M, T, O> where
M: Mutability,
T: BitStore,
O: BitOrder,
impl<'_, '_, M, T, O> PartialOrd<&'_ bool> for BitRef<'_, M, T, O> where
M: Mutability,
T: BitStore,
O: BitOrder,
fn partial_cmp(&self, other: &&bool) -> Option<Ordering>
sourceimpl<R> PartialOrd<BitSel<R>> for BitSel<R> where
R: PartialOrd<R> + BitRegister,
impl<R> PartialOrd<BitSel<R>> for BitSel<R> where
R: PartialOrd<R> + BitRegister,
fn partial_cmp(&self, other: &BitSel<R>) -> Option<Ordering>
sourceimpl<T, O, Rhs> PartialOrd<Rhs> for BitVec<T, O> where
T: BitStore,
O: BitOrder,
Rhs: PartialOrd<BitSlice<T, O>> + ?Sized,
impl<T, O, Rhs> PartialOrd<Rhs> for BitVec<T, O> where
T: BitStore,
O: BitOrder,
Rhs: PartialOrd<BitSlice<T, O>> + ?Sized,
fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>
sourceimpl<R> PartialOrd<BitIdx<R>> for BitIdx<R> where
R: PartialOrd<R> + BitRegister,
impl<R> PartialOrd<BitIdx<R>> for BitIdx<R> where
R: PartialOrd<R> + BitRegister,
fn partial_cmp(&self, other: &BitIdx<R>) -> Option<Ordering>
sourceimpl<'_, T1, T2, O1, O2> PartialOrd<BitSlice<T2, O2>> for &'_ mut BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'_, T1, T2, O1, O2> PartialOrd<BitSlice<T2, O2>> for &'_ mut BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, rhs: &BitSlice<T2, O2>) -> Option<Ordering>
sourceimpl<A, T, O> PartialOrd<BitArray<A, O>> for BitSlice<T, O> where
A: BitViewSized,
T: BitStore,
O: BitOrder,
impl<A, T, O> PartialOrd<BitArray<A, O>> for BitSlice<T, O> where
A: BitViewSized,
T: BitStore,
O: BitOrder,
fn partial_cmp(&self, other: &BitArray<A, O>) -> Option<Ordering>
sourceimpl<'_, T1, T2, O1, O2> PartialOrd<BitSlice<T2, O2>> for &'_ BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'_, T1, T2, O1, O2> PartialOrd<BitSlice<T2, O2>> for &'_ BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, rhs: &BitSlice<T2, O2>) -> Option<Ordering>
sourceimpl<'a, T, O> PartialOrd<IterOnes<'a, T, O>> for IterOnes<'a, T, O> where
T: PartialOrd<T> + 'a + BitStore,
O: PartialOrd<O> + BitOrder,
impl<'a, T, O> PartialOrd<IterOnes<'a, T, O>> for IterOnes<'a, T, O> where
T: PartialOrd<T> + 'a + BitStore,
O: PartialOrd<O> + BitOrder,
fn partial_cmp(&self, other: &IterOnes<'a, T, O>) -> Option<Ordering>
sourceimpl<T> PartialOrd<BitSpanError<T>> for BitSpanError<T> where
T: PartialOrd<T> + BitStore,
impl<T> PartialOrd<BitSpanError<T>> for BitSpanError<T> where
T: PartialOrd<T> + BitStore,
fn partial_cmp(&self, other: &BitSpanError<T>) -> Option<Ordering>
sourceimpl<'a, T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for &'a mut BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'a, T1, T2, O1, O2> PartialOrd<BitVec<T2, O2>> for &'a mut BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, other: &BitVec<T2, O2>) -> Option<Ordering>
sourceimpl<A, O, Rhs> PartialOrd<Rhs> for BitArray<A, O> where
A: BitViewSized,
O: BitOrder,
Rhs: ?Sized,
BitSlice<<A as BitView>::Store, O>: PartialOrd<Rhs>,
impl<A, O, Rhs> PartialOrd<Rhs> for BitArray<A, O> where
A: BitViewSized,
O: BitOrder,
Rhs: ?Sized,
BitSlice<<A as BitView>::Store, O>: PartialOrd<Rhs>,
fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>
sourceimpl<'_, T1, T2, O1, O2> PartialOrd<&'_ BitSlice<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'_, T1, T2, O1, O2> PartialOrd<&'_ BitSlice<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, rhs: &&BitSlice<T2, O2>) -> Option<Ordering>
sourceimpl<T1, T2, O1, O2> PartialOrd<BitSlice<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<T1, T2, O1, O2> PartialOrd<BitSlice<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
Compares two BitSlice
s by semantic — not representational — ordering.
The comparison sorts by testing at each index if one slice has a high bit where the other has a low. At the first index where the slices differ, the slice with the high bit is greater. If the slices are equal until at least one terminates, then they are compared by length.
fn partial_cmp(&self, rhs: &BitSlice<T2, O2>) -> Option<Ordering>
sourceimpl PartialOrd<Msb0> for Msb0
impl PartialOrd<Msb0> for Msb0
fn partial_cmp(&self, other: &Msb0) -> Option<Ordering>
sourceimpl<T> PartialOrd<MisalignError<T>> for MisalignError<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<MisalignError<T>> for MisalignError<T> where
T: PartialOrd<T>,
fn partial_cmp(&self, other: &MisalignError<T>) -> Option<Ordering>
sourceimpl<O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for BitSlice<T1, O1> where
O1: BitOrder,
O2: BitOrder,
T1: BitStore,
T2: BitStore,
impl<O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for BitSlice<T1, O1> where
O1: BitOrder,
O2: BitOrder,
T1: BitStore,
T2: BitStore,
fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<Ordering>
sourceimpl<'_, M, T, O> PartialOrd<bool> for BitRef<'_, M, T, O> where
M: Mutability,
T: BitStore,
O: BitOrder,
impl<'_, M, T, O> PartialOrd<bool> for BitRef<'_, M, T, O> where
M: Mutability,
T: BitStore,
O: BitOrder,
fn partial_cmp(&self, other: &bool) -> Option<Ordering>
sourceimpl<'_, T1, T2, O1, O2> PartialOrd<&'_ mut BitSlice<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'_, T1, T2, O1, O2> PartialOrd<&'_ mut BitSlice<T2, O2>> for BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, rhs: &&mut BitSlice<T2, O2>) -> Option<Ordering>
sourceimpl<R> PartialOrd<BitIdxError<R>> for BitIdxError<R> where
R: PartialOrd<R> + BitRegister,
impl<R> PartialOrd<BitIdxError<R>> for BitIdxError<R> where
R: PartialOrd<R> + BitRegister,
fn partial_cmp(&self, other: &BitIdxError<R>) -> Option<Ordering>
sourceimpl<'_, '_, M1, M2, O1, O2, T1, T2> PartialOrd<BitRef<'_, M2, T2, O2>> for BitRef<'_, M1, T1, O1> where
M1: Mutability,
M2: Mutability,
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'_, '_, M1, M2, O1, O2, T1, T2> PartialOrd<BitRef<'_, M2, T2, O2>> for BitRef<'_, M1, T1, O1> where
M1: Mutability,
M2: Mutability,
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, other: &BitRef<'_, M2, T2, O2>) -> Option<Ordering>
sourceimpl<'_, '_, T1, T2, O1, O2> PartialOrd<&'_ BitSlice<T2, O2>> for &'_ mut BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
impl<'_, '_, T1, T2, O1, O2> PartialOrd<&'_ BitSlice<T2, O2>> for &'_ mut BitSlice<T1, O1> where
T1: BitStore,
T2: BitStore,
O1: BitOrder,
O2: BitOrder,
fn partial_cmp(&self, rhs: &&BitSlice<T2, O2>) -> Option<Ordering>
sourceimpl<T> PartialOrd<BitPtrError<T>> for BitPtrError<T> where
T: PartialOrd<T> + BitStore,
impl<T> PartialOrd<BitPtrError<T>> for BitPtrError<T> where
T: PartialOrd<T> + BitStore,
fn partial_cmp(&self, other: &BitPtrError<T>) -> Option<Ordering>
sourceimpl<M1, M2, T1, T2, O> PartialOrd<BitPtr<M2, T2, O>> for BitPtr<M1, T1, O> where
M1: Mutability,
M2: Mutability,
T1: BitStore,
T2: BitStore,
O: BitOrder,
impl<M1, M2, T1, T2, O> PartialOrd<BitPtr<M2, T2, O>> for BitPtr<M1, T1, O> where
M1: Mutability,
M2: Mutability,
T1: BitStore,
T2: BitStore,
O: BitOrder,
fn partial_cmp(&self, other: &BitPtr<M2, T2, O>) -> Option<Ordering>
sourceimpl<R> PartialOrd<BitEnd<R>> for BitEnd<R> where
R: PartialOrd<R> + BitRegister,
impl<R> PartialOrd<BitEnd<R>> for BitEnd<R> where
R: PartialOrd<R> + BitRegister,
fn partial_cmp(&self, other: &BitEnd<R>) -> Option<Ordering>
sourceimpl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a mut BitSlice<T1, O1> where
O1: BitOrder,
O2: BitOrder,
T1: BitStore,
T2: BitStore,
impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a mut BitSlice<T1, O1> where
O1: BitOrder,
O2: BitOrder,
T1: BitStore,
T2: BitStore,
fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<Ordering>
sourceimpl<T, O, Rhs> PartialOrd<Rhs> for BitBox<T, O> where
T: BitStore,
O: BitOrder,
Rhs: PartialOrd<BitSlice<T, O>> + ?Sized,
impl<T, O, Rhs> PartialOrd<Rhs> for BitBox<T, O> where
T: BitStore,
O: BitOrder,
Rhs: PartialOrd<BitSlice<T, O>> + ?Sized,
fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>
sourceimpl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a BitSlice<T1, O1> where
O1: BitOrder,
O2: BitOrder,
T1: BitStore,
T2: BitStore,
impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a BitSlice<T1, O1> where
O1: BitOrder,
O2: BitOrder,
T1: BitStore,
T2: BitStore,
fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<Ordering>
impl<M1, M2, T1, T2> PartialOrd<Address<M2, T2>> for Address<M1, T1> where
M1: Mutability,
M2: Mutability,
impl<M1, M2, T1, T2> PartialOrd<Address<M2, T2>> for Address<M1, T1> where
M1: Mutability,
M2: Mutability,
fn partial_cmp(&self, other: &Address<M2, T2>) -> Option<Ordering>
impl PartialOrd<Const> for Const
impl PartialOrd<Const> for Const
fn partial_cmp(&self, other: &Const) -> Option<Ordering>
impl PartialOrd<Mut> for Mut
impl PartialOrd<Mut> for Mut
fn partial_cmp(&self, other: &Mut) -> Option<Ordering>
impl PartialOrd<NullPtrError> for NullPtrError
impl PartialOrd<NullPtrError> for NullPtrError
fn partial_cmp(&self, other: &NullPtrError) -> Option<Ordering>
impl<Inner> PartialOrd<Frozen<Inner>> for Frozen<Inner> where
Inner: PartialOrd<Inner> + Mutability,
impl<Inner> PartialOrd<Frozen<Inner>> for Frozen<Inner> where
Inner: PartialOrd<Inner> + Mutability,
fn partial_cmp(&self, other: &Frozen<Inner>) -> Option<Ordering>
Implementors
impl PartialOrd<TypeDefPrimitive> for TypeDefPrimitive
impl PartialOrd<MetaForm> for MetaForm
impl PartialOrd<PortableForm> for PortableForm
impl PartialOrd<Ordering> for Ordering
impl PartialOrd<MetaType> for MetaType
impl PartialOrd<TypeId> for TypeId
impl PartialOrd<Error> for Error
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<NonZeroUsize> for NonZeroUsize
impl PartialOrd<String> for String
impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>
impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>
impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
B: PartialOrd<B> + ToOwned + ?Sized,
impl<'a, T: PartialOrd> PartialOrd<Symbol<'a, T>> for Symbol<'a, T>
impl<K, V> PartialOrd<BTreeMap<K, V>> for BTreeMap<K, V> where
K: PartialOrd<K>,
V: PartialOrd<V>,
impl<T> PartialOrd<BTreeSet<T>> for BTreeSet<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<LinkedList<T>> for LinkedList<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<PhantomData<T>> for PhantomData<T> where
T: ?Sized,
impl<T> PartialOrd<ManuallyDrop<T>> for ManuallyDrop<T> where
T: PartialOrd<T> + ?Sized,
impl<T> PartialOrd<Saturating<T>> for Saturating<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<Wrapping<T>> for Wrapping<T> where
T: PartialOrd<T>,
impl<T> PartialOrd<Reverse<T>> for Reverse<T> where
T: PartialOrd<T>,
impl<T, A> PartialOrd<Box<T, A>> for Box<T, A> where
T: PartialOrd<T> + ?Sized,
A: Allocator,
impl<T, A> PartialOrd<VecDeque<T, A>> for VecDeque<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.