Trait wasmtime_environ::__core::prelude::rust_2015::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 &'a OsStr
impl<'a, 'b> PartialOrd<Path> for &'a OsStr
fn partial_cmp(&self, other: &Path) -> Option<Ordering>
sourceimpl PartialOrd<str> for OsString
impl PartialOrd<str> for OsString
fn partial_cmp(&self, other: &str) -> Option<Ordering>
sourceimpl PartialOrd<str> for OsStr
impl PartialOrd<str> for OsStr
fn partial_cmp(&self, other: &str) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b Path
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<Cow<'a, Path>> for OsStr
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for OsStr
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, OsStr>
fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>
sourceimpl PartialOrd<SocketAddr> for SocketAddr
impl PartialOrd<SocketAddr> for SocketAddr
fn partial_cmp(&self, other: &SocketAddr) -> Option<Ordering>
1.16.0 · sourceimpl PartialOrd<Ipv6Addr> for IpAddr
impl PartialOrd<Ipv6Addr> for IpAddr
fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<OsString> for Cow<'a, OsStr>
fn partial_cmp(&self, other: &OsString) -> 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 PartialOrd<Instant> for Instant
impl PartialOrd<Instant> for Instant
fn partial_cmp(&self, other: &Instant) -> 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 PartialOrd<SystemTime> for SystemTime
impl PartialOrd<SystemTime> for SystemTime
fn partial_cmp(&self, other: &SystemTime) -> 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>
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>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for Path
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'a OsStr> for 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<OsStr> for Path
impl<'a, 'b> PartialOrd<OsStr> for Path
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
sourceimpl PartialOrd<CString> for CString
impl PartialOrd<CString> for CString
fn partial_cmp(&self, other: &CString) -> 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<Cow<'a, OsStr>> for OsString
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsString
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for &'b OsStr
1.8.0 · sourceimpl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<&'b OsStr> for Cow<'a, Path>
fn partial_cmp(&self, other: &&'b OsStr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<Path> for Cow<'a, OsStr>
fn partial_cmp(&self, other: &Path) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, OsStr>
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr
impl<'a, 'b> PartialOrd<Cow<'a, OsStr>> for OsStr
sourceimpl PartialOrd<CStr> for CStr
impl PartialOrd<CStr> for CStr
fn partial_cmp(&self, other: &CStr) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr
impl<'a, 'b> PartialOrd<PathBuf> for &'a OsStr
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
sourceimpl PartialOrd<OsString> for OsString
impl PartialOrd<OsString> for OsString
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 OsString
impl<'a, 'b> PartialOrd<PathBuf> for OsString
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for &'a OsStr
impl<'a, 'b> PartialOrd<OsString> for &'a OsStr
fn partial_cmp(&self, other: &OsString) -> Option<Ordering>
sourceimpl PartialOrd<OsStr> for OsStr
impl PartialOrd<OsStr> for OsStr
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>
impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, OsStr>
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
sourceimpl PartialOrd<Ipv6Addr> for Ipv6Addr
impl PartialOrd<Ipv6Addr> for Ipv6Addr
fn partial_cmp(&self, other: &Ipv6Addr) -> 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>
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 Cow<'a, Path>
impl<'a, 'b> PartialOrd<Path> for Cow<'a, Path>
fn partial_cmp(&self, other: &Path) -> 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>
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<&'b Path> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<&'b Path> for Cow<'a, Path>
fn partial_cmp(&self, other: &&'b Path) -> 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.16.0 · sourceimpl PartialOrd<Ipv4Addr> for IpAddr
impl PartialOrd<Ipv4Addr> for IpAddr
fn partial_cmp(&self, other: &Ipv4Addr) -> 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<OsString> for Path
impl<'a, 'b> PartialOrd<OsString> for Path
fn partial_cmp(&self, other: &OsString) -> 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<PathBuf> for Path
impl<'a, 'b> PartialOrd<PathBuf> for Path
fn partial_cmp(&self, other: &PathBuf) -> Option<Ordering>
1.16.0 · sourceimpl PartialOrd<IpAddr> for Ipv4Addr
impl PartialOrd<IpAddr> for Ipv4Addr
fn partial_cmp(&self, other: &IpAddr) -> 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<OsStr> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<OsStr> for Cow<'a, Path>
fn partial_cmp(&self, other: &OsStr) -> 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
sourceimpl PartialOrd<ErrorKind> for ErrorKind
impl PartialOrd<ErrorKind> for ErrorKind
fn partial_cmp(&self, other: &ErrorKind) -> Option<Ordering>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsStr> for OsString
impl<'a, 'b> PartialOrd<OsStr> for OsString
fn partial_cmp(&self, other: &OsStr) -> Option<Ordering>
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<&'a Path> for Cow<'b, OsStr>
impl<'a, 'b> PartialOrd<&'a Path> for Cow<'b, OsStr>
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>
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<&'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<PathBuf> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<PathBuf> for Cow<'a, Path>
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>
1.8.0 · sourceimpl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>
impl<'a, 'b> PartialOrd<OsString> for Cow<'a, Path>
fn partial_cmp(&self, other: &OsString) -> 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.8.0 · sourceimpl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path
impl<'a, 'b> PartialOrd<Cow<'a, Path>> for Path
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>
sourceimpl PartialOrd<Ipv4Addr> for Ipv4Addr
impl PartialOrd<Ipv4Addr> for Ipv4Addr
fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering>
1.45.0 · sourceimpl PartialOrd<SocketAddrV4> for SocketAddrV4
impl PartialOrd<SocketAddrV4> for SocketAddrV4
fn partial_cmp(&self, other: &SocketAddrV4) -> 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<&'a Path> for PathBuf
impl<'a, 'b> PartialOrd<&'a Path> for PathBuf
fn partial_cmp(&self, other: &&'a 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<OsStr> for &'a Path
impl<'a, 'b> PartialOrd<OsStr> for &'a Path
fn partial_cmp(&self, other: &OsStr) -> 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>
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>
sourceimpl PartialOrd<i64> for i64
impl PartialOrd<i64> for i64
sourceimpl<A, B, C, D, E, F, G, H, I, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J> + ?Sized,
impl<A, B, C, D, E, F, G, H, I, J> PartialOrd<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J> + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J)
) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool
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 PartialOrd<usize> for usize
impl PartialOrd<usize> for usize
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<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, 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<u8> for u8
impl PartialOrd<u8> for u8
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> 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<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> 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, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
sourceimpl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
impl<T> PartialOrd<*mut T> for *mut T where
T: ?Sized,
1.4.0 · sourceimpl<Ret, A, 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<char> for char
impl PartialOrd<char> for char
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<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F> + ?Sized,
impl<A, B, C, D, E, F> PartialOrd<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F> + ?Sized,
sourceimpl PartialOrd<u128> for u128
impl PartialOrd<u128> for u128
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H, I, J> 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> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A) -> Ret> for unsafe extern "C" fn(A) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H> 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, 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>
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<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> 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> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F> 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>
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> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
impl<Ret, A, B, C> PartialOrd<unsafe fn(A, B, C) -> Ret> for unsafe fn(A, B, C) -> Ret
fn partial_cmp(&self, other: &unsafe fn(A, B, C) -> Ret) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B> 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.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> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret
impl<Ret, A, B> PartialOrd<fn(A, B) -> Ret> for fn(A, B) -> Ret
fn partial_cmp(&self, other: &fn(A, B) -> Ret) -> Option<Ordering>
sourceimpl PartialOrd<isize> for isize
impl PartialOrd<isize> for isize
1.4.0 · sourceimpl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret
impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(A, B, C, D) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I, J, K> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<u32> for u32
impl PartialOrd<u32> for u32
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> 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> 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<A, B, C, D, E, F, G, H, I, J, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K> + ?Sized,
impl<A, B, C, D, E, F, G, H, I, J, K> PartialOrd<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I>,
J: PartialOrd<J> + PartialEq<J>,
K: PartialOrd<K> + PartialEq<K> + ?Sized,
fn partial_cmp(
&self,
other: &(A, B, C, D, E, F, G, H, I, J, K)
) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool
sourceimpl<A, B, C, D, E, F, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G> + ?Sized,
impl<A, B, C, D, E, F, G> PartialOrd<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G> + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G)) -> bool
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H> PartialOrd<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<f32> for f32
impl PartialOrd<f32> for f32
sourceimpl<T> PartialOrd<[T]> for [T] where
T: PartialOrd<T>,
impl<T> PartialOrd<[T]> for [T] where
T: PartialOrd<T>,
Implements comparison of vectors lexicographically.
fn partial_cmp(&self, other: &[T]) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A> 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> 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>
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<A, B> PartialOrd<(A, B)> for (A, B) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B> + ?Sized,
impl<A, B> PartialOrd<(A, B)> for (A, B) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B> + ?Sized,
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> 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> 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> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret
impl<Ret, A, B, C, D, E, F, G> PartialOrd<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for extern "C" fn(A, B, C, D, E, F, G) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I, J> PartialOrd<unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, 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> 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<A, B, C, D, E, F, G, H, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I> + ?Sized,
impl<A, B, C, D, E, F, G, H, I> PartialOrd<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H>,
I: PartialOrd<I> + PartialEq<I> + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H, I)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool
sourceimpl PartialOrd<i32> for i32
impl PartialOrd<i32> for i32
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<T> PartialOrd<*const T> for *const T where
T: ?Sized,
impl<T> PartialOrd<*const T> for *const T where
T: ?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 PartialOrd<f64> for f64
impl PartialOrd<f64> for f64
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> 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> 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> 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> 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<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C> + ?Sized,
impl<A, B, C> PartialOrd<(A, B, C)> for (A, B, C) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C> + ?Sized,
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<A> PartialOrd<(A,)> for (A,) where
A: PartialOrd<A> + PartialEq<A> + ?Sized,
impl<A> PartialOrd<(A,)> for (A,) where
A: PartialOrd<A> + PartialEq<A> + ?Sized,
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> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
impl<Ret, A, B, C, D> PartialOrd<unsafe extern "C" fn(A, B, C, D, ...) -> Ret> for unsafe extern "C" fn(A, B, C, D, ...) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, B, C, D, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F> 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<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<()> for ()
impl PartialOrd<()> for ()
fn partial_cmp(&self, &()) -> 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> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
impl<Ret, A> PartialOrd<unsafe extern "C" fn(A, ...) -> Ret> for unsafe extern "C" fn(A, ...) -> Ret
fn partial_cmp(
&self,
other: &unsafe extern "C" fn(A, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> PartialOrd<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret
impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F) -> Ret> for extern "C" fn(A, B, C, D, E, F) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F) -> Ret
) -> Option<Ordering>
1.4.0 · sourceimpl<Ret, A, B, 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> 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<i8> for i8
impl PartialOrd<i8> for i8
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<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> 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> PartialOrd<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
impl<Ret, A, B, C, D, E, F> PartialOrd<extern "C" fn(A, B, C, D, E, F, ...) -> Ret> for extern "C" fn(A, B, C, D, E, F, ...) -> Ret
fn partial_cmp(
&self,
other: &extern "C" fn(A, B, C, D, E, F, ...) -> Ret
) -> Option<Ordering>
sourceimpl PartialOrd<i16> for i16
impl PartialOrd<i16> for i16
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, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D> + ?Sized,
impl<A, B, C, D> PartialOrd<(A, B, C, D)> for (A, B, C, D) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D> + ?Sized,
sourceimpl PartialOrd<i128> for i128
impl PartialOrd<i128> for i128
sourceimpl PartialOrd<!> for !
impl PartialOrd<!> for !
fn partial_cmp(&self, &!) -> Option<Ordering>
sourceimpl PartialOrd<u16> for u16
impl PartialOrd<u16> for u16
1.4.0 · sourceimpl<Ret, A, B, C, D, E, F, G, H, I> PartialOrd<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<bool> for bool
impl PartialOrd<bool> for bool
fn partial_cmp(&self, other: &bool) -> 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>
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<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<'_, '_, 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<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E> + ?Sized,
impl<A, B, C, D, E> PartialOrd<(A, B, C, D, E)> for (A, B, C, D, E) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E> + ?Sized,
sourceimpl PartialOrd<u64> for u64
impl PartialOrd<u64> for u64
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<'_, '_, 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<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, 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, 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>
sourceimpl<A, B, C, D, E, F, G, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H> + ?Sized,
impl<A, B, C, D, E, F, G, H> PartialOrd<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
A: PartialOrd<A> + PartialEq<A>,
B: PartialOrd<B> + PartialEq<B>,
C: PartialOrd<C> + PartialEq<C>,
D: PartialOrd<D> + PartialEq<D>,
E: PartialOrd<E> + PartialEq<E>,
F: PartialOrd<F> + PartialEq<F>,
G: PartialOrd<G> + PartialEq<G>,
H: PartialOrd<H> + PartialEq<H> + ?Sized,
fn partial_cmp(&self, other: &(A, B, C, D, E, F, G, H)) -> Option<Ordering>
fn lt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
fn le(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
fn ge(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
fn gt(&self, other: &(A, B, C, D, E, F, G, H)) -> bool
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> PartialOrd<fn() -> Ret> for fn() -> Ret
impl<Ret> PartialOrd<fn() -> Ret> for fn() -> Ret
fn partial_cmp(&self, other: &fn() -> 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<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<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 PartialOrd<String> for String
impl PartialOrd<String> for String
fn partial_cmp(&self, other: &String) -> 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<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<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
B: PartialOrd<B> + ToOwned + ?Sized,
impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B> where
B: PartialOrd<B> + ToOwned + ?Sized,
fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>
sourceimpl<T, A> PartialOrd<Vec<T, A>> for Vec<T, A> where
T: PartialOrd<T>,
A: Allocator,
impl<T, A> PartialOrd<Vec<T, A>> for Vec<T, A> where
T: PartialOrd<T>,
A: Allocator,
Implements comparison of vectors, lexicographically.
fn partial_cmp(&self, other: &Vec<T, A>) -> Option<Ordering>
sourceimpl<T> PartialOrd<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<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));